[Noisebridge-discuss] Seeding to give advanced java performance tunings seminar, java certification seminar, in order to afford the 21 computers for my lab, ...for an intelligent os, that models loop causality in the sound timone... ( multithread

Tue Aug 10 19:50:01 UTC 2010

I love your art, especially
http://www.mungbeing.com/issue_10.html?page=40#923  and
http://www.mungbeing.com/issue_10.html?page=43#926.  Also this composition:
"Autincissions veneraete" by Erin Emerson,
2006<http://www.mungbeing.com/media/erin_emerson-autincissions_veneraete.mp3>.
 You obviously are a very multi-talented individual.

-- Don

On Mon, Aug 9, 2010 at 1:59 PM, Erin Emerson <starlypt at gmail.com> wrote:

> years worth of virtual hosting so that they can elicit their own contracts,
> (I simply need a couch and a space around other programmers and graphic
> artists in order to do the other sessions in the living room (lcd projectors
> ... ) because I am charging $200/session for the twoweek session for
> everyo9ne else... (non programmers and graphic artists.... free at the noise
> bridge and to some people.... (the remaining sessions at home +year of
> virtual hosting, and access to all of my graphic images.....and debugging,
> etc...
>
>
> audio programmming ...and etc...
>
> but at the base, Advanced java performance tunings seminar and java
> certification seminar.
> 2 week session, free at noise bridge for beginning, free to other artists,
> hackers, $200/ to others.
>
>
> Sample tutorial:
> Examples from my tutorials and the UNIX systems programming seminar, and
> java cert. seminar I will be giving, [and the Advanced Java Performance
> tunings seminar I will be giving]: Because java is architecture neutral and
> runs on a virtual machine which is implemented across any platform, not
> dependent upon unique libraries or architectures, strict adherence to
> specifications is necessary:
>
>
> In my actual tutorials, all is referenced implicitly/explained:
>
>
>
> .See as follows:
>
>
> On Atomism and assignment:
>
> Variables shared between multiple threads (e.g., instance variables of
> objects) have atomic assignment for all data types except for longs and
> doubles. [The a
> ssinging of Longs and doubles [being 64bit [8 bytes] are actually
> 2 atomic operations, all single writes and accesses to memory are 32bits [4
> bytes] for each store and write] Actually, the storing of a value into a
> variable takes two basic/primitive operations, store and write. However, the
> language specification also states that once a store operation occurs on a
> particular variable, no other store operation is allowed on that variable
> until the write operation has occurred. The specification allows longs and
> doubles[64 bits] to be stored in two separate sets of store+write
> operations, hence their exception to atomic assignment. A similar atomic
> operation exists in the reading
> of basic datatypes.
>
> So the access and rewrite of variables are automatically synchronized (as
> long as they are not longs or doubles). If a method consists solely of a
> variable access or assignment, there is no need to make it synchronized for
> thread safety, and every reason not to do so for performance. Thread safety
> extends further to any set of statements that are accessing or assigning to
> a variable independently of any other variable values. The exclusion here
> precludes setting a variable that depends on the value of another variable
> as already have been written to memory, an inherently unsafe act; this would
> be two separate operations, which is inherently not thread-safe. For
> example:
>
> public void setMe(Object o) {me = o;}
> public Object getMe( ) {return me;}
>
> are thread-safe methods, with no need for synchronized modifiers to be
> added to the method declaration. On the other hand:
>
> public void setMe(Object o) {if(overwrite) me = o;}
>
> is not thread-safe: overwrite may be true at the time of the if comparison,
> but false by the time the of the assignment to the variable me. Anything
> with more instructions than a simple assignment and access is an implicit
> instability, race condition, or .......can cause chaos for any global object
> that requires simultaneous thread access, writes [example, a gui [or one of
> my synths, ] in which a keyevent must be logged before the proceeds..
> [if...: it depends on whether any particular intermediate state that can be
> accessed is considered corrupt by the appl[ication]. Consider the code being
> halted before or after any particular atomic statement, and decide whether
> or not another thread could now access the corrupted var, event......
>
> Attaching the synchronization identifier is essential to lock all objects
> globally at once, such that because an atomic write and store may allow for
> a 32bit datatype to be in one state before the actual write, synchronization
> actually locks them all out at once, through mutual exclusion, such that
> globally they are locked until the entire set of atomic operations for each
> individual method assigning that object are complete before allowing another
> thread method access. The global lock at once, is essential because basic
> atomic writes may be different before committance to memory.
>
>
>
> [Anyway, THE ABOVE WAS AN OLD TUTORIAL< IT WAS NOTHING COMPARED TO WHAT I
> WRITE NOW,
> what i write NOW is as good as my ART..!
> Initialization and Scoping, and declaration:
>
> * Develop code that declares classes (including abstract and all forms of
> nested classes), interfaces, and enums, and includes the appropriate use of
> package and import statements (including static imports).
> * Develop code that declares an interface. Develop code that implements or
> extends one or more interfaces. Develop code that declares an abstract
> class. Develop code that extends an abstract class.
> * Develop code that declares, initializes, and uses primitives, arrays,
> enums, and objects as static, instance, and local variables. Also, use legal
> identifiers for variable names.
> * Develop code that declares both static and non-static methods, and - if
> appropriate - use method names that adhere to the JavaBeans naming
> standards. Also develop code that declares and uses a variable-length
> argument list.
> * Given a code example, determine if a method is correctly overriding or
> overloading another method, and identify legal return values (including
> covariant returns), for the method.
> * Given a set of classes and superclasses, develop constructors for one or
> more of the classes. Given a class declaration, determine if a default
> constructor will be created, and if so, determine the behavior of that
> constructor. Given a nested or non-nested class listing, write code to
> instantiate the class.
>
>
>
> Flow Control
>
> * Develop code that implements an if or switch statement; and identify
> legal argument types for these statements.
> * Develop code that implements all forms of loops and iterators, including
> the use of for, the enhanced for loop (for-each), do, while, labels, break,
> and continue; and explain the values taken by loop counter variables during
> and after loop execution.
> * Develop code that makes use of assertions, and distinguish appropriate
> from inappropriate uses of assertions.
> * Develop code that makes use of exceptions and exception handling clauses
> (try, catch, finally), and declares methods and overriding methods that
> throw exceptions.
> * Recognize the effect of an exception arising at a specified point in a
> code fragment. Note that the exception may be a runtime exception, a checked
> exception, or an error.
> * Recognize situations that will result in any of the following being
> thrown: ArrayIndexOutOfBoundsException,ClassCast Exception,
> IllegalArgumentException, IllegalStateException, NullPointerException,
> NumberFormatException, AssertionError, ExceptionInInitializerError,
> StackOverflowError or NoClassDefFoundError. Understand which of these are
> thrown by the virtual machine and recognize situations in which others
> should be thrown programatically.
>
>
>
> API [wrappers around primitives,] J2SE API:
>
> * Develop code that uses the primitive wrapper classes (such as Boolean,
> Character, Double, Integer, etc.), and/or autoboxing & unboxing. Discuss the
> differences between the String, StringBuilder, and StringBuffer classes.
> * Given a scenario involving navigating file systems, reading from files,
> writing to files, or interacting with the user, develop the correct solution
> using the following classes (sometimes in combination), from java.io:
> BufferedReader, BufferedWriter, File, FileReader, FileWriter, PrintWriter,
> and Console.
> * Develop code that serializes and/or de-serializes objects using the
> following APIs from java.io: DataInputStream, DataOutputStream,
> FileInputStream, FileOutputStream, ObjectInputStream, ObjectOutputStream and
> Serializable.
> * Use standard J2SE APIs in the java.text package to correctly format or
> parse dates, numbers, and currency values for a specific locale; and, given
> a scenario, determine the appropriate methods to use if you want to use the
> default locale or a specific locale. Describe the purpose and use of the
> java.util.Locale class.
> * Write code that uses standard J2SE APIs in the java.util and
> java.util.regex packages to format or parse strings or streams. For strings,
> write code that uses the Pattern and Matcher classes and the String.split
> method. Recognize and use regular expression patterns for matching (limited
> to: . (dot), * (star), + (plus), ?, \d, \s, \w, [], ()). The use of *, +,
> and ? will be limited to greedy quantifiers, and the parenthesis operator
> will only be used as a grouping mechanism, not for capturing content during
> matching. For streams, write code using the Formatter and Scanner classes
> and the PrintWriter.format/printf methods. Recognize and use formatting
> parameters (limited to: %b, %c, %d, %f, %s) in format strings.
>
>
>
> Concurrency
>
> * Write code to define, instantiate, and start new threads using both
> java.lang.Thread and java.lang.Runnable.
> * Recognize the states in which a thread can exist, and identify ways in
> which a thread can transition from one state to another.
> * Given a scenario, write code that makes appropriate use of object locking
> to protect static or instance variables from concurrent access problems.
> * Given a scenario, write code that makes appropriate use of wait, notify,
> or notifyAll.
>
>
>
> OO Concepts
>
> * Develop code that implements tight encapsulation, loose coupling, and
> high cohesion in classes, and describe the benefits.
> * Given a scenario, develop code that demonstrates the use of polymorphism.
> Further, determine when casting will be necessary and recognize compiler vs.
> runtime errors related to object reference casting.
> * Explain the effect of modifiers on inheritance with respect to
> constructors, instance or static variables, and instance or static methods.
> * Given a scenario, develop code that declares and/or invokes overridden or
> overloaded methods and code that declares and/or invokes superclass, or
> overloaded constructors.
> * Develop code that implements "is-a" and/or "has-a" relationships.
>
>
>
> Collections /: standard util inherited libs:
>
> * Given a design scenario, determine which collection classes and/or
> interfaces should be used to properly implement that design, including the
> use of the Comparable interface.
> * Distinguish between correct and incorrect overrides of corresponding
> hashCode and equals methods, and explain the difference between == and the
> equals method.
> * Write code that uses the generic versions of the Collections API, in
> particular, the Set, List, and Map interfaces and implementation classes.
> Recognize the limitations of the non-generic Collections API and how to
> refactor code to use the generic versions. Write code that uses the
> NavigableSet and NavigableMap interfaces.
> * Develop code that makes proper use of type parameters in class/interface
> declarations, instance variables, method arguments, and return types; and
> write generic methods or methods that make use of wildcard types and
> understand the similarities and differences between these two approaches.
> * Use capabilities in the java.util package to write code to manipulate a
> list by sorting, performing a binary search, or converting the list to an
> array. Use capabilities in the java.util package to write code to manipulate
> an array by sorting, performing a binary search, or converting the array to
> a list. Use the java.util.Comparator and java.lang.Comparable interfaces to
> affect the sorting of lists and arrays. Furthermore, recognize the effect of
> the "natural ordering" of primitive wrapper classes and java.lang.String on
> sorting.
>
>
>
> Fundamentals
>
> * Given a code example and a scenario, write code that uses the appropriate
> access modifiers, package declarations, and import statements to interact
> with (through access or inheritance) the code in the example.
> * Given an example of a class and a command-line, determine the expected
> runtime behavior.
> * Determine the effect upon object references and primitive values when
> they are passed into methods that perform assignments or other modifying
> operations on the parameters.
> * Given a code example, recognize the point at which an object becomes
> eligible for garbage collection, determine what is and is not guaranteed by
> the garbage collection system, and recognize the behaviors of the
> Object.finalize() method.
> * Given the fully-qualified name of a class that is deployed inside and/or
> outside a JAR file, construct the appropriate directory structure for that
> class. Given a code example and a classpath, determine whether the classpath
> will allow the code to compile successfully.
> * Write code that correctly applies the appropriate operators including
> assignment operators (limited to: =, +=, -=), arithmetic operators (limited
> to: +, -, *, /, %, ++, --), relational operators (limited to: <, <=, >, >=,
> ==, !=), the instanceof operator, logical operators (limited to: &, |, ^, !,
> &&, ||), and the conditional operator ( ? : ), to produce a desired result.
> Write code that determines the equality of two objects or two primitives.
>
>
>
> There will be mock exams, and I can almost guarantee, to those who are
> willing,
> [while the passing of the exam only requires 47 out of 72 questions, or
> 65%, I can almost guarantee all will pass beyond...[expectation], In my case
> I earned a 95th%
> If I were to take it now, it would probably be higher.
> But there WILL BE MOCK EXAMS.
> + 1 year virtual hosting, SEO, debugging consultation for clients to elicit
> contracts.\\\
> Link
> //probabli be done by tomorrow...
>
>
> [graphics soon after..://look at freebirth if you want to see something [if
> you want to see the effects I am adding to it....
>
> .../lots of blending occillators..[and adding my own..[1-2 effects later,
> at first, then later.
> [freebirth is the best i have used anywhere..
> http://www.bitmechanic.com/projects/freebirth/doc.html
>
> Making jarcase-instant sampler 10 times better..!
> class pro.fuse.audio.EffectManager
> {
> var effects, songFactory, sync;
> static var instance;
> function EffectManager(Void)
> {
> effects = new Array();
> songFactory = pro.fuse.SongFactory.getInstance();
> } // End of the function
> static function getInstance(Void)
> {
> if (pro.fuse.audio.EffectManager.instance == undefined)
> {
> return (instance = new pro.fuse.audio.EffectManager());
> } // end if
> return (pro.fuse.audio.EffectManager.instance);
> } // End of the function
> function setSync(sync)
> {
> this.sync = sync;
> } // End of the function
> function addEffect(source, effectName, bassoccillator, channelIndex,
> stepIndex)
> {
> switch (effectName)
> {
> case "flanger":
> {
> effects[channelIndex] = new org.audiopackage.effects.Flanger(sync);
> effects[channelIndex].setSource(source);
> var _loc3 = songFactory.getEffect(channelIndex);
> this.changeFlanger(effects[channelIndex], "speed", _loc3.speed);
> this.changeFlanger(effects[channelIndex], "range", _loc3.range);
> break;
> }
> case "delay":
> {
> effects[channelIndex] = new org.audiopackage.effects.Delay(sync);
> effects[channelIndex].setSource(source);
> _loc3 = songFactory.getEffect(channelIndex);
> this.changeDelay(effects[channelIndex], "rate", _loc3.rate);
> this.changeDelay(effects[channelIndex], "damp", _loc3.damp);
> break;
> }
> case "bass_occillator";
> (
> effect[channelIndez] = new org.audiopackage.effects.occillator(sync);
> effect[channelIndex].setSource(source);
> _loc3 = songFactory.getEffect(channelIndex);
> this.bassoccillator.setbasssynth (stepIndex, _loc3.bassset);
> this.bassoccillator.changeEffect (stepIndex, bassoccillator.type, "freq",
> _loc3.freq);
> this.bassoccillator.changeEffect (stepIndex, bassoccillator.type, "phase",
> _loc3.phase);
> this.bassoccillator.changeEffect (stepIndex, bassoccillator.type, "blend",
> _loc3.blend);
> case "filter";
> case "tap_delay";
> (
> case "pitch";
> (
> effect[channelIndex] = new org.audiopackage.effects.pitch(sync);
> effect[channelIndex].stepIndex.setSource(source);
> _loc3 = songFactory.getEffect(channelIndex);
> this.pitch(effects[channelIndex].stepIndex, "pitch", _loc3.pitch);
> break;
>
> case "reverb";
> (
>
>
> } // End of switch
> } // End of the function
> function removeEffect(channelIndex)
> {
> effects[channelIndex].setSource(null);
> } // End of the function
> function changeEffectProperty(barIndex, effectName, propertyName, value)
> {
> switch (effectName)
> {
> case "flanger":
> {
> this.changeFlanger(effects[barIndex], propertyName, value);
> break;
> }
> case "delay":
> {
> this.changeDelay(effects[barIndex], propertyName, value);
> break;
> }
> case "bass_occillator";
> if (this.baseoccillator() = false) {
> }
> else {(for this.bass_occillator.change_on== false){
> switch (this.bass_occillator.occillator_effect) {
> case "saw_freq_change":
> this.changesaw_freq(propertyName, value);
> this.bass_occillator.change_on = true;
> }
> case "sqr_freq_change";
> this.changesqr_freq(propertyName, value);
> this.bass_occillator.change_on = true;
> }
> case "sin_freq_change";
> this.changesin_freq(propertyName, value);
> }}} this.bass_occillator.change_on = true;}
>
> this.bass_occillator.blend_mas_occillator();
> }
> } // End of switch
> } // End of the function
> function changeFlanger(effect, propertyName, value)
> {
> switch (propertyName)
> {
> case "speed":
> {
> effect.setSpeed(value / 400 * 3.141593E+000);
> break;
> }
> case "range":
> {
> effect.setRange(value / 50000);
> break;
> }
> } // End of switch
> } // End of the function
> function changeDelay(effect, propertyName, value)
> {
> switch (propertyName)
> {
> case "rate":
> {
> effect.setRate(value);
> break;
> }
> case "damp":
> {
> effect.setDamp((100 - value) / 125);
> break;
> }
> } // End of switch
> } // End of the function
> } // End of Class
> function bass_occillator.blend_mas_occillator (this) {
> this.change_freq()
> this._phase_offshift()
> this.change_
> function bassoccillator(effect, propertyName, value) {
> switch (propertyName)
> case "sin_occillator";
> (
> effect.change_sin__occillatorfreq(value);
> break;
> )
> case "sqr_occillator";
> effect.change_sin__occillatorfreq(value);
> break;
> )
> case "saw_occillator";
> effect.change_sin__occillatorfreq(value);
> break;
> )
> this.
>
>
>
>
>
> i though e were over feeling 'uilty' for eing our highest self.../// [Dec.
> 31st, 2037|07:36 pm]
> hehe...!
>
> i just 0o.
> that e will be 'the best..//and i just 0o. the best...!
>
>
> all the others with elationshsipts say.."i can't hve a roomfor(florefor
> youi...(ecause my girslsmfriseds may not lif4eks its.
>
> .... so simply ecause you are so good you are at the mercy of
> random...(curious opposites trainstation.... (
>
> the im shipst.
>
> im shipts./ (ime rabbit) :eris y,(if) eris says eris see eris see heresy).
> signed erin emerson,. ... (great great grat grand uncle == ralph waldo
> emerson) (3)
> born, 3/22/78, equinox, a 2, sat. may, 23, 3:22 am. (let's celebrate..onli
> for the ism hsipst, iso::ios in./
>
>
>
>
>
>
>
>
> balibali bees....billi bees drinking puptible teas for psychobilli
> bove betters for little orbits of billitrees...
> .....'you're so ..cute.....worrynever"
>
> loveli lees....
> .
> []-------------
> canisters of promolgamaeted, sexy entomologists drinking mimmi cans
> ofsemmiotiddi, sights of mechanicanical mechanical avunculogratulation
>
>
> gesso babies delight...cryeegenic,noeticisight...gess o babies
> delight...cryeegenic,noeticisight...
>
> mechanical avuncolugratulation=build machines for greeting uncles..
> rereading "my cousin, my gastroentrologist.."
>
>
> ibbiti bibbiti pight..
>
> pyes blinking
>
>
> corpuscibble igits of tibbi tibbi tak s..
>
> porrogulaeted gesso babies in flight..[ itotonic cooing babies, bidi]
> onecombinuous membranous wax:
> beedibeedi..babies licking gesso promolgamies of canned mimies
>
>
>
>
> .immnaetbiddleiddleiddle nmeumoni nmeumoni aordic..bidi corpuscuouls
> nmemonic spaces.corpuscuouls=
> .corpuscible igits of wellness by ~nmeumoni-nmeumoni
> "balibali bees....billi bees drinking puptible teas for psychobilli bove
> betters for little orbits of billitrees... .....'you're so
> ..cute.....worrynever"
> loveli lees.... . []------------- canisters of promolgamaeted, sexy
> entomologists drinking mimmi cans ofsemmiotiddi, sights of mechanicanical
> mechanical avunculogratulation
>
> gesso babies delight...cryeegenic,noeticisight...gesso babies
> delight...cryeegenic,noeticisight...
> mechanical avuncolugratulation=build machines for greeting uncles..
> rereading "my cousin, my gastroentrologist.."
>
> ibbiti b"
>
> "balibali bees....billi bees drinking puptible teas for psychobilli bove
> betters for little orbits of billitrees... .....'you're so
> ..cute.....worrynever"
> loveli lees.... . []------------- canisters of promolgamaeted, sexy
> entomologists drinking mimmi cans ofsemmiotiddi, sights of mechanicanical
> mechanical avunculogratulation
>
> gesso babies delight...cryeegenic,noeticisight...gesso babies
> delight...cryeegenic,noeticisight...
> mechanical avuncolugratulation=build machines for greeting uncles..
> rereading "my cousin, my gastroentrologist.."
>
> ibbiti b"
>
>
> peripherial and punctuous starry and unctuous....
> writ to a lampaed ear...
>
> kneesocks and newsprint [letter from 2096]....
> ...'mascurade thesaurus'
>
>
> -
> toursaery gesso babies on porrogaeted cisscionwax drink delight!
> gesso babies delight...cryeegenic,noeticisight...
>
> pyes blinking
>
> -
> o babi spire: ancient .architectures [old journal IIyears ago:
> [link]
> [x]
>
> _______________________________________________
> Noisebridge-discuss mailing list
> Noisebridge-discuss at lists.noisebridge.net
> https://www.noisebridge.net/mailman/listinfo/noisebridge-discuss
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.noisebridge.net/pipermail/noisebridge-discuss/attachments/20100810/513d3440/attachment-0002.html>