text:
User talk:72.57.8.2I5~enwikibooks

Please leave your message after the click!!

I love the name
I should have dropped a line to you earlier. This is a cool user name, and throws convention and common preconceptions about new users to the wind. I love to see some fresh blood come in here and stir the pot up, so to say, and it will make for some interesting discussions.

BTW, Welcome to Wikibooks. I hope you have better success in the future than what apparently your book How To Ride The Bus. When you copied the content over to the new title, I ended up turning the old title into a redirect. This is nothing personal against you, but simply a way to inform everybody where the content ended up at. I tried to preserve all of the changes that you made after the page move. Moving pages to avoid deletion is generally frowned upon and is more likely to increase the potential of getting deleted.

I should have removed the VfD right after it started. I've done that two a couple other books, but I've also had quite a bit of flack from other Wikibooks regulars because of that. Apprarently Derbeth doesn't believe in waiting to see a Wikibook get started to see just where it might go. He has done a lot of good for Wikibooks, however, so don't consider him to be the spawn of the Devil. And his is just one opinion out of many as well anyway, and no permanent damage has been done to your book (yet).

It is too bad that you want to assert non-GFDL copyright status on the book. While from a strictly legal standpoint I don't think you can do that, if you don't want the content on Wikibooks I can understand, particularly given the hostile reaction to the book. There is no reason to keep the content here if you don't want it on Wikibooks. It is an interesting reaction to the community BTW, and one that I support as well. --Rob Horning 18:25, 12 February 2006 (UTC)

 * My meandering thoughts: Thank You Mr. Rob. The alias started out with me wondering, perhaps I could register my static IP address as a user; I tried user:72.57.8.215X but didn't like the X. You hit did however hit the spot. I tend, as you may have observed from the title of my first article, to rock the boat a little and add controversial material. I am an artist after all. Anyway I took 72.57.8.2I5 because so I could remember my close link and try to get credit for my previous edits as IP:72.57.8.215 To be perfectly honest, I like the idea of wikibooks. I wish however that it would be all fun and fun! Where people could come along and say... hmm.. I don't really know what I can add to that but that's interesting. Maybe I should look into it. Instead of saying... I don't really know what I can add into that. Let's delete it! I also didn't want to remove the VfD from fear that wikibookians would be mad. But I couldn't really stand waiting letting this issue go on. I have so many idea for building the book. When I'm on wikibooks, it just seems so much easier write an article then if I did it in my word editor. It seems easier to make references, footnotes, etc... I actually want the book to be out there. But you know what. Once it's out there I'm probably going to bang myself on the head and say "I should have just wrote it in word." I keep it in the dark files, encrypted, as one of those never to publish idea from fear of being put into jail, labeled crazy, and having people shoot the messenger. Well, I think I should have expected some sort of protest. But I didn't expect this big of a pot stir. Perhaps this is an issue that we should discuss at the deletion policy page. Interesting enough, I'm sure there will be more similar nominations. I have a lot more documentation and scribbles here at home of the original book concept. I also wonder about the GFDL licence?  If I could claim that? No matter the case. I have plenty of ideas. The problem with this one article is that I've taken it personal. This policy stuff, well until your pep talk, Isn't really motivating. As soon as you add rules you restrict creativity. The Art of writing! At the moment, to contribute anymore to this book as I would do on my regular word editor.

b.t.w.: I would have thought that after changing the name we would have a better leg to stand on!! But... well anyway! This is such a mess, with red-tap, I feel like I'm in an episode of watching the OJ Simpson trial. I just hope this case is fairly judged.

p.s: I'm at the point where I'm obviously becoming indifferent if the article is deleted or not. But rest assure, the world is watching... I will remember.. And for some reason I'm feeling a little bitter now. The reason being that this nomination is still there and that I'm evaluating my self existence right now and the meaning of wikibooks within this thing of mine called life! Thank you for the kind words. And I'm sure Derbeth did not intend to do this entire process as an evil act. But that fact that no is doing anything about it doesn't seems send happy feelings into my consciousness. We'll just have to see what happens and if I start fixing up the article again or not. Thank you again for listening. Perhaps it would be wise to further this dicussion into some sort of proposed rule? (as I've noticed you've done already with some issues, elaborated into a nice article in a sub-page within your user page) ;) --72.57.8.2I5 00:58, 13 February 2006 (UTC)

 * As an addeed thought... I hope you continue to stay active. I am trying to encourage new users on Wikibooks, particuarly those who have come here just because they like the idea of Wikibooks and havn't necessarily started out on Wikipedia.  Discussion like this have happened before, and I even had a Wikibook that was slapped with a VfD only 18 hours after I started the content.  This killed the early momentum in getting it going, and squashed even my own contributions to instead have to deal with the stupid VfD (that was rejected by the community on top of the whole thing).  I've become somewhat of a Wikimedia lawyer, as long as a court of opinion can be maintained and not changed through executive decrees.  See the Wikimania discussion for what IMHO is an abuse of power by those "in charge" at the Wikimedia Foundation.  My attitude is to give as much support to the new users, and have mild contempt for the veterans... especially if they are throwing their weight around.  To be a Wikimedia veteran you need to have a fairly thick skin anyway, so a litle heated verbage usually goes off each other's backs.

 * Again... Welcome to Wikibooks. This is going to be a very significant and influential project that will be as significant as Wikipedia, IMHO.  It just needs some passionate people to help get it going.  --Rob Horning 15:48, 17 February 2006 (UTC)

Super Smash Bros. Melee/Trophies
I don't think your rewording will be enough. It's still too similar to the original work and will probably be just as much a copyvio as it is now. Gerard Foley 02:32, 13 February 2006 (UTC)

Thank you for your honest reply. I trust your judgement. It would however be nice to have a second opinion. Hence... My reply can also be found on the delete discusion...

I guess you read through my first 4 translations? You obviously have a copy of the original work somewhere. Is this a book that looks like this,ie. similar format? If we reword it shouldn't it be okay? The only trouble I see is if the entire article is base on one source... I'm guessing that's what you mean right. We would need more sources to diversify and less chances of a general format copyvio? --72.57.8.2I5 02:43, 13 February 2006 (UTC)

The stuff in the Description col is word for word what is found in the video game. I put a link to google Images on the delete discusion which has screenshots of that part of the game so people can check for themselfs. Gerard Foley 03:23, 13 February 2006 (UTC)

Agreement
I am in complete agreement with your assessment of Derbeth. Evil - good choice of words (I can think of unpublishable ones). Thanks! - marsh 05:12, 16 February 2006 (UTC)

French Wikibook
You're one of only a few users who know both French and English natively. Would you mind editing and expanding the French Wikibook? --Hagindaz 07:16, 3 March 2006 (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 72.57.8.2I5. To make sure that both of you can use all Wikimedia projects in future, we have reserved the name 72.57.8.2I5~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 22:54, 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) 04:28, 19 April 2015 (UTC)

title: User talk:72.57.8.2I5~enwikibooks


text:
Introspector/RelatedProjects/SimilarNamed

JavaBeansIntrospector? http://java.sun.com/j2se/1.3/docs/api/java/beans/Introspector.html

The Introspector class provides a standard way for tools to learn about the properties, events, and methods supported by a target Java Bean.

For each of those three kinds of information, the Introspector will separately analyze the bean's class and superclasses looking for either explicit or    implicit information and use that information to build a BeanInfo object that comprehensively describes the target bean.

For each class "Foo", explicit information may be available if    there exists a corresponding "FooBeanInfo" class that provides a non-null value when queried for the information. We first look for the BeanInfo class by taking the full package-qualified name of the target bean class and appending "BeanInfo" to form a new class name. If this fails, then we take the final classname component of this name, and look for that class in each of    the packages specified in the BeanInfo package search path.

Thus for a class such as "sun.xyz.OurButton" we would first look for a BeanInfo class called "sun.xyz.OurButtonBeanInfo" and if that failed we'd look in each package in the BeanInfo search path for an    OurButtonBeanInfo class. With the default search path, this would mean looking for "sun.beans.infos.OurButtonBeanInfo".

If a class provides explicit BeanInfo about itself then we add that to the BeanInfo information we obtained from analyzing any derived classes, but we regard the explicit information as being definitive for the current class and its base classes, and do not proceed any further up the superclass chain.

If we don't find explicit BeanInfo on a class, we use low-level reflection to study the methods of the class and apply standard design patterns to identify property accessors, event sources, or public methods. We then proceed to analyze the class's superclass and add in the information from it    (and possibly on up the superclass chain).

For more information about introspection and design patterns, please consult the JavaBeans specification.

http://java.sun.com/products/javabeans/docs/index.html

CastorIntrospector? http://castor.exolab.org/api/org/exolab/castor/xml/Introspector.html

A Helper class for the Marshaller and Unmarshaller, basically the common code base between the two. This class handles the introspection to    dynamically create descriptors.

Creates an XMLClassDescriptor? http://castor.exolab.org/api/org/exolab/castor/xml/XMLClassDescriptor.html

A class descriptor for describing relationships between a Class and an XML element or complexType. This class implements org.exolab.castor.mapping.ClassDescriptor, yet adds extra methods for handling XML. All fields are of type XMLFieldDescriptor.

RepastIntrospector? http://repast.sourceforge.net/docs/api/uchicago/src/reflector/Introspector.html

Introspect eCM http://www.steelpoint.com/introspect/

Introspect eCM, the industry’s leading case management, litigation support, and compliance risk management software product, uses advanced e-Discovery technology to rapidly and efficiently aggregate all paper-based and electronically stored data - including all employee, client, and partner correspondences. Introspect qualifies data for searching, foldering, and reviewing; analyzes data for risks; and produces any and all corporate information necessary to ensure compliance and protection from litigation.

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


text:
Introspector/LanguageTools/SilverScheme/Doc

-- Objects --

Everything in SilverScheme is an object. An object consists of two parts: a code section and an field list. The code section may contain a lambda expression. The field list is basically a hash with unique keys, the values refer to other objects.

-- Scope --

Scope is complicated. SilverScheme, like any modern LISP has lexical scope (block scope). To understand scope in SilverScheme a little knowledge of the syntax is required.

Every definition is basically a (define), lambda list is (name value . forms). The forms are evaluated in the scope of the (newly created) object. For example (define a 10 (define b 20)) will create a new object a with value 10 and with an attribute b with value 20. Thus a.b = 20.

When you say (define a.b 30) you define in the current scope a new binding for symbol b as field of object a. An example demonstrates some things: (define a 10 (define b 20)) (define-ref c a) ;c is an alias for a (define d a) ;d is a copy of a (define a.b 30) a.b = 30 c.b = 30 d.b = 20

Thus (define a.b value) doesn't set a.b, but it sets the binding of symbol b to object a.

Wow, I've finally managed to get scope working decently :-).

For your understanding here are a few simple facts:
 * An object is in a box, a memory location.
 * A field points to a box.
 * The object id is actually the box id.
 * The set! function changes the object in a box.
 * The define function makes a field point to a different box.

-- Pass-by-reference, pass-by-value --

The general rule of SilverScheme is that function arguments are passed by reference. However two basic functions are an exception on this. Arguments to (define) are passed by value, (define-ref) is the normal reference one, thus (define) can be seen as (define-ref), but with arg.copy done for each argument.

The let construct also needs pass-by-value to keep consistent with define (and to avoid easily made hard to find bugs). To indicate reference one must put
 * ref before the clause. For example:

(let ((a 10) ;a is by-value :ref (b 20)) ;b is by-ref     __some_code__)

Granted, assigning by reference to a literal is stupid (literals are constant), but this demonstrates the principle.

Copies in SilverScheme (pass-by-value creates copies) use copy-on-write. I guess you already know how copy-on-write works.

-- Metadata --

SilverScheme is designed around the concept that: a) code should be free, in all it's forms and b) that if you don't do that somebody else will ;-). All information about an object is accessible through it's metadata interface. The metadata interface consists of roughly two parts: documentation contributed by the user and information gathered by the interpreter.

The meta field is also where all attributes are stored. An attribute in SilverScheme is simply an object. The user can thus easily define attributes.

There are thus roughly three types of objects of metadata: the documentation, the reflection info and custom attributes. The documentation is placed into the obj.documentation field in hash form. Both reflection and custom attributes go into obj.meta in normal object form.

SilverScheme supports documentation through the Argentum [1] scheme. Argentum is the POD of SilverScheme. Documentation can be put in doc comments of the form ;...\n and #!! ... !# (multi-line). Doc comments use a syntax similar to YAML.

Attributes can be easily created using (define meta.attrname value).

-- Classes --

SilverScheme has a weird way of implementing classes. The instance of a class is defined as a field of that class named 'prototype'. The constructor then does (create-instance), (create-instance) adds the needed class information to a copy of the prototype.

Note that classes can access private members of their prototypes and vice versa.

To access the class of an object you can use the obj.class field (or the obj.meta.class field).

An example of a simple class: (define-class Foo (Object Bar) ;;Foo inherits from Object                              ;;and promises to implement                               ;;the public interface of Bar  (define-prototype ;;(define prototype) doesn't work! (define baz 10)))

-- Inheritance --

SilverScheme does not support multiple inheritance. Instead it has interface inheritance and mixins (later more about that). Every class after the first is interface inherited. Interface inheritance means that a class only inherits from the parent in name, not in code (aka no code is copied).

Note that it's not possible to inherit from a non-class. This is to keep the class mechanism simple.

-- Mixins --

SilverScheme uses mixins to do what other languages do with multiple inheritance. A mixin is an object that has fields marked with the (mixin) attribute. The object can also be marked with the (full-mixin) attribute, essentially giving all it's fields the mixin attributes.

When an object has the (use-mixin __mixin_name__) attribute it copies the source code of the mixin fields in the mixin and evaluates them in the current scope. Kinda like how Ruby does it. This is used for example to give objects the <, <=, =, etc functions for free if they have the <=> function and say (use-mixin Comparable).

-- Domains --

SilverScheme provides some powerful tools to make programming without bugs easier. The most important one is domains. A domain is a function that takes one argument, and checks if that argument is in the domain. If so nothing happens, if not an Domain-Violation-Error is thrown. Domains have three main uses: checking variables, enforcing preconditions, enforcing postconditions.

To check a variable against a domain one simply uses the (domain) self-applying attribute (most attributes are self-applying btw). For example: (define a 5 ;domain: 0 < a < 5 (domain (\ (value) (and (> value 0) (< value 11)))))

The domain function accepts a few keywords after the lambda expression:
 * read -- Check the domain whenever the variable contents are read.
 * write -- Check the domain whenever the variable contents are written.

The keywords may be used both.

By default only :write is on. The domain-default-operation environment variable is used to set the default to a different value.

To check a preconditions replace the argument name with (argument-name domain): (\ ((a (\ (value) ;domain: a > 0 (> a 0))))   ...)

The domain may be in a variable (useful for often used domains).

Another way to do preconditions is to use the (pre-condition __arg_name__ __domain__) attribute. The advantage of the attribute is that you can use it conditionally (for example in a testing situation, but not in production use)

To check a postcondition use the (post-condition) attribute. For example: (define simple-add (\ (a b) (+ a b)) (post-domain (\ (value) (> value 0))))

The Argentum documentation extractor (agdoc) also extracts domains, so using them is a good way to show what the pre- and postconditions are.

-- owner, parent, super --

In a.b object defined as (define a 10 (define b 20)) a owns object b since b was defined by object a. Object b has full access to the private members of object a. For object b object a is known by as 'owner'. The variable 'owner' always points to the owner of an object.

The parent of an object is the prototype of the superclass.

The super variable refers to parent.__name_of_this_function__.

-- call/cc, call/tf, call/rf --

SilverScheme call/cc (call-with-current-continuation) is pretty much like the standard Scheme call/cc. However it has some more argument passing power. When you do (call/cc (\ (b) (b 10 20))) then the resulting continuation has a field values which contains a list of the values passed to it. When you invoke the continuation with the arguments the arguments are given as the result of the break function, always as a list.

The call/tf (call-with-throw-function) function is like the Guile catch function. It takes one argument, a lambda list with one parameter, the throw function. When the throw function is invoked a non-local exit is done to the call/tf, like with call/cc, however there is no return. The arguments passed to the throw function are returned by (call/tf) as a list in the second element of a list (the first element if #t if no non-local exit occurred and #f otherwise).

The call/rf function is similar. However it doesn't signal success or failure and returns the list directly (not as a sublist).

-- Exceptions --

Exceptions are build upon call/tf and work roughly like this:

(try (begin __code_to_be_tried__) (catch (__exception_class__  __code_to_be_executed_on_that_exception__) (__exception_class__  __code_to_be_executed_on_that_exception__) ...) (finally __code_that_should_always_be_executed))

Pretty simple isn't it? The (throw) function is rigged to go to the nearest exception handler at all times. It's not quite schemisch, but it looks pretty good :-).

-- conditional evaluation of parameters --

Normally parameters are evaluated left to right. SilverScheme has an easy way to create an exception on that however. For example: (\ (`a b `(c (\ (val) (> val 10))) (if (b)  a   c))

Right, stupid example, but it demonstrates my point. If you put a backquote before the argument in the lambda list the argument will not be evaluated until needed.

-- macros --

A macro is a function that returns a list that is evaluated in the scope of the caller. A macro is also an ideal way to get a virus in a SilverScheme system. A macro is made by simply creating a function and then attaching the (macro) attribute to it.

Macros can be dangerous, they can be helpful too however. It depends on the situation what they are. That's why I'm introducing set-macro-safe. The set-macro-safe function takes one argument which is either a number or a symbol and sets the macro-safe level to that argument. The possible arguments are: 0 'allow-all -- Allow normal macro behaviour for all macros. 1 'explicit-deny -- Allow normal macro behaviour for all macro's except when explicitly told not to do that. 2 'allow-base -- Allow normal macro behaviour for all macro's in the Base hierarchy (the baselib). Disallow normal macro behaviour for all other macros unless explicitly told otherwise. 3 'explicit-allow -- The same as 'allow-base, except that the Base macro's aren't automatically allowed anymore. 4 'deny-all -- Deny all macro's.

Some primitive macro's are allowed regardless of what the macro-safe level says.

Macro's that can't be called with normal macro behaviour can still be called, but they only take a single argument (a list) and produce a list that must be explicitly evaluated (using '(eval list)').

The standard macro level is 0. Note that that's not a safe level for any production code.

At the first deny command the macro level automatically gets set to 1, if it's not already at that or a lower level. Thus level 0 can be regarded as level 1, however it's faster since the macro deny checks are off.

-- Dynamic binding and environment variables --

Sometimes it's handy to pass arguments to functions without putting them in the argument list but by defining a variable and having the function read that variable. In the case (begin (define a 10) (foo)) foo can't read a, and it shouldn't. For environment variables like macro-safe it's another situation however. That's why I'm introducing environment variables.

Environment variables are dynamically bound. They can't leave the scope in which they are defined however (like any other variable). To define an environment variable you need a special function (define-environment-variable) aka (defenv). This function simply behaves like a normal define, except that the variable is automatically set read-only (you can override, but normally it's what you want). The variable can then be accessed using env.variable-name, note that 'env' is a special variable.

Almost all the special variables can be accessed using env too (env.super, env.owner, etc), they only have names without env in them because they are used so much that it's reasonable to shorten them. The macro-safe variable is however only accessible with env.macro-safe (it's a read-write variable btw).

A word of warning is due here, don't define environment variables unless you really need them, it's bad style to depend on them for stuff you should pass in a parameter list.

-- compilation --

SilverScheme is like any Scheme compilable. However SilverScheme has multiple compiling modes.

The standard mode is keep-all, which basically creates a resource section in the executable and puts the literal code files in it. The keep-all mode has the advantage that the result (obj.source) will have the same markup and comments as the original. Since the data is put in resource files the actual code can be executed pretty fast. Needless to say this actually increases file size.

A second mode is keep-source, this mode only keeps the actual source code, not comments. It helps keep the file size down.

A third mode is keep-minimum, removing all the comments and sources except those referred to in the program. Good for really small files, bad for readability. Note that since documentation is put into the objects it can't be removed by this mode.

The fourth and most drastic mode is keep-minimum-remove-docs, this mode also kicks out the documentation. Only useful if you really really want a small program.

An implementation may compress resource files with tar and gzip at any compression level. I recommend not or very weakly compressing the actual sources but strongly compressing the documentation.

The extension of a SilverScheme source file is .dgs, the extension of a SilverScheme compiled file is .dgsb (SilverScheme Bytecode).

Note that the SilverScheme bytecode is not IL, Parrot or machinecode though compiling to these is allowed as an optional feature. The SilverScheme bytecode is a special bytecode designed for SilverScheme (probably looking like other LISP bytecodes).

-- Permissions --

The permission system is aimed at providing flexible authorization for certain objects to do certain things. Permissions are given with tokens. Access tokens give an object A the power to get/set/invoke object B even if this is forbidden by the access system (access system: public SUBSET-OF {'read 'write 'invoke}, private SUBSET-OF {'read 'write 'invoke}). Here's an example of access tokens:

(define a 10 (read-only) ;;(public 'read 'invoke) (private 'read 'write 'invoke)  (define giver (\      (a.give-token-to-caller 'a.write)) (a.give-bag-access)))

In this example 'a is first declared read-only (that's the default actually), then a function a.giver is declared and made read-only implicitly. The giver function is given bag-access by 'a. Any object can give bag access during it's definition or at any time through it's code. The giver function now gives write permission for a to any object that calls it. There is no caller object by the way since I consider it a bad idea if code can manipulate things up the stack except in such special cases.

There is a second kind of tokens called custom tokens. Basically a custom token is a token that doesn't have an implicit action associated with it. An example of a custom token system:

(define nice 0 (define set ;accessor (\ (value)     (if (< value 0) (if (caller-has-token? 'system.root-access)         (set! nice value)         (throw (Invalid-Rights-Exception "You don't have root permissions"))        (set! nice value))))

Without the root-access token you can't use it.

To be honest, custom tokens don't feel right yet. I'd rather leave them out of the language for now, letting them mature first, I included them only for completeness sake.

-- Static --

The fields of an object can be divided into two parts: static and non-static. Static fields are conceptually bound to the storage box of the object and stick around when set! is used. However static and non-static fields are in the same namespace, so if a non-static field is in the new value during set! it will override the old value. Here's an example:

(define a 10 (define set (\ ((value (\ (val) (> val 10))))  (set! owner value)) (static))) (set! a 20) ;set! obj -> obj.set (a.set.source) => (\ ((value (\ (val) (> val 10)))) (set! owner value))

-- Overload and override --

When defining a subclass and overloading a field one often easily uses define. This is a bad idea however since define creates a whole new field that doesn't share any of the attributes and stuff like that with the old field. Instead SilverScheme has a method called (overload) which is used like this: (define-class Foo  (define bar (\ __some_code__) (private)))

(define-class Fred (Foo) (overload bar ((\ __some_other_code__))))

And voila, bar is copied. Here's a template for overload: (overload __name__ (__new_value__) __attributes__). If the new value part is empty the value isn't changed (that's why I have it between parenthesises).

The (define) function will do an override. In some cases it might be helpful to warn or throw an error when define is used. In such cases the (override) function (which is simply define with another name) is useful.

The override error checking can be turned on and off using the environment variable check-override-errors.

-- Temporary environment variables --

It's possible to create temporary environment variables that only exist in a certain scope. One can use the (let-environment-variable) function for this, it takes the same kinds of arguments as let, but puts them under env. The advantage over a set..body..unset construction is that let-environment-variable automatically unsets on error.

-- Primitives --

SilverScheme's version of intercalls are called primitives. Primitives are always functions (RPC functions to be exact), but they are not objects. Primitives can only be called from Base (baselib). Any attempt to do weird things with primitives may be punished with unexpected behaviour (rationale: it's internal stuff, only a few core hackers will touch it and they will know what to do). There is one primitive handler which is defined as (call-primitive name . args) and is private in the top level of the Base module. The primitive handler can take and return complex objects, however mostly it will operate on simple things.

The advantage of a single primitive handler over for example a primitive attribute is that there is just one entry point that's easily documented. After all the accepted function names will probably be visible in a switch statement.

-- Relative modification --

The basic idea behind serialization in SilverScheme is 'relative modification'. Instead of saying "send this object" the serialization mechanism says "I've got an object with this identity, do you need it". Obviously you don't need the same object twice, so the amount of data send over the network is decreased.

Another possibility with the serialization mechanism is sending in patches to serialized libraries. This has a huge advantage, namely that you only need to send the actual changes, instead of the textual changes (diff sometimes sends over half the file for one line changed, SilverScheme would never do that).

The trick in serialization is the basic SilverScheme object itself. This is how an object looks like:

object                    field ++             +---+ ++        |     +---+ ++        |     +-+-+ +--+-+        |     +-+-+ +--+-+        | +--+-+        | ++
 * identity |        +---> |  subject  |
 * prototype |       |     |  name     |
 * changed  |        |     |  object |C|
 * ivalue |C|        |
 * code   |C|        |
 * scope    | ---+

The C subfields are change flags.

The identity of an object is to the outside world an uri like 'http://myproject/1003', internally it's a number. The identity of an object is unique, no two different objects with the same identity can exist at any time.

The prototype of an object is the object that this object is a copy of. Often this is the prototype of the class of the object, in case the object is copied using for example define it's the original (the second arg to define). Objects can have prototypes that are not in the current session (like a prototype from the web).

The changed flag of an object is set on whenever the object is no longer a perfect copy of the prototype. The changed flag is a kind of warning flag, it doesn't tell what has changed only that something has changed.

The ivalue is the internal value of an object. It's were for example the value of a String object is stored in the native representation of the string (or more likely a pointer to the native representation of the string). It has a changed flag to signal when the internal value has changed.

The code property is the code section of an object. It has a changed flag to signal when the code has changed.

For each field in the scope there is a name, a subject reference and an object reference with a changed flag. If the field is bound to a new object (with a different identity) the change flag goes on.

To send over an object one first needs to ask the other party if he has the prototype. If not the whole object is send over. If he has the prototype one must look at the object's change flag, if it's off one can suffice with saying "it's a perfect copy of the prototype", otherwise one has to look up which change flags are on and send over the information in those properties.

-- The library system --

SilverScheme has two types of libraries: source libraries and static state libraries (I'll call them state libraries from now on). A source library is simply a bunch of SilverScheme source files. A state library is a serialized library. Typically a state library is a relative serialization patch against it's dependencies (to keep lib size down) and some extra files (like pictures, should it be needed).

State libraries are usually published on the WWW with an URI like this: 'http://domain/prefix/name/build/', for example 'http://somedomain/home/peter/myproject/12/'. The prefix is just the path to the project directory. The build is a number that increases when you create a new build of the state files, it runs independent of the version number and is the primary means of identifying a version of the library. Additionally there may be something like 'http://somedomain/home/peter/myproject/0.0.1/' where the version number is just an alias for a certain build number.

-- Introspection --

Static state files in SilverScheme are similar to the output of the introspector, indeed they are the output of the build-in SilverScheme introspector. Thus they contain all information about a program (at the time of serialization), except the stack and some other information needed for running (non-static state files contain these, but that stuff is out of scope here (I'm not even sure if there will ever be non-static state files)). Thus the (static) state files contain all the information needed for analyzation of the library. I'll create an ontology for the state files similar to the introspector ontology for the introspected IL files so that the state files will be processable with the introspector toolchain, given a few small adaptions to cope with the language differences. Unfortunately I can't use the introspector ontology due to the differences between SilverScheme and IL.

-- The SilverScheme Repository --

This is really wishful dreaming, but a nice dream :-). The SilverScheme Repository will be something like CPAN, but more extended toward introspection. It will keep libraries as both compressed source and as state files, it will keep programs (executable programs) as compressed source (you can't really serialize those to static state files since there is no natural idle point where the program is loaded but not executing). Due to an intelligent toolchain coupled to a webservice and web interface it's possible to see the structure of libraries, the documentation of libraries, etc, generated on demand out of the state files.


text:
Introspector/LanguageTools/SilverScheme/Ontology

@prefix : . @prefix dc: . @prefix owl: . @prefix : . @prefix rdfs: . @prefix owl: . @prefix xmls: .
 * 1) Following URI is just a placeholder

 * Object rdf:Comment """A SilverScheme object, contains a property list, a

code field and an identity field.""" ;	rdf:Type owl:Class.

 * ObjectPrototype rdf:Comment """The prototype of an object.""" ;

rdf:Type rdf:Property ; rdf:Domain :Object ; rdf:Range :Object.

 * ObjectInternalValue rdf:Comment """The internal value of an object.""" ;

rdf:Type rdf:Property ; rdf:Domain :Object ; rdf:Range :InternalValue.

 * InternalValue rdf:Comment """The literal representation of an

internal value, the representation is that used by		             the standard SilverScheme reader.""" ; 	      rdfs:subClassOf xmls:String.

 * ObjectCode rdf:Comment """The code of an object.""" ;

rdf:Type rdf:Property ; rdf:Domain :Object ; rdf:Range :Code.

 * Code rdf:Comment """A code section.""" ;

rdf:Type owl:Class.

 * LambdaList rdf:Comment """The lambda list of a code section. A list

of course.""" ;	   rdf:Type rdf:Property ;	    rdf:Domain :Code ;	    rdf:Range :Object.

 * 1) TODO: Additional constraint on :LambdaList so that it's always a list

 * LambdaBody rdf:Comment """The body of a lambda expression. A list of

course.""" ;	   rdf:Type rdf:Property ;	    rdf:Domain :Code ;	    rdf:Range :Object.

 * ObjectScope rdf:Comment """The scope of an object.""" ;

rdf:Type rdf:Property ; rdf:Domain :Object ; rdf:Range :Scope.

 * Scope rdf:Comment """A scope list, basically just a triples list""" ;

rdf:Type owl:Class.

 * ScopeBinding rdf:Comment """A binding in a scope.""" ;

rdf:Type rdf:Property ; rdf:Domain :Scope ; rdf:Range :Binding.

 * Binding rdf:Comment """A binding.""" ;

rdf:Type owl:Class.

 * BindingSubject rdf:Comment """The subject of a binding.""" ;

rdf:Type rdf:Property ; rdf:Domain :Binding ; rdf:Range :Object.

 * BindingName rdf:Comment """The name of a binding, must be a valid

SilverScheme identifier.""" ;            rdf:Type rdf:Property ;             rdf:Domain :Binding ;             rdf:Range xmls:String.

 * BindingObject rdf:Comment """The object of a binding.""" ;

rdf:Type rdf:Property ; rdf:Domain :Binding ; rdf:range :Object.


text:
Introspector/KifTutorial

This is a short example based tutorial of Knowledge Interchange Format. It's not complete nor very correct, but it should give you an idea about what you can do with KIF.

The knowledge base I'm using here is a simple representation of human relations. Basically two types of relation exist: family and friends. There are three kinds of family: father, mother, child. There is only one kind of friend. For our purposes partners are also friends. Let's start by entering some data:

(male Fred) (male John) (female Martha) (female Joan) (female Betty) (female Alice)

Fred and John are males, Martha, Joan, Betty and Alice are females.

(father Fred John)

John is the father of Fred

(mother Fred Martha)

Martha is the mother of Fred

(father Pete Fred)

Fred is the father of Pete

(mother Pete Joan)

Joan is the mother of Pete

(friend Pete Betty)

Betty is a friend of Pete

(mother Alice Martha)

Martha is the mother of Alice

(mother Betty Alice)

Alice is the mother of Betty

Now it's nice if we could get some information from these relations. For example _we_ know Fred is the child of Pete, but the computer doesn't. Let's tell him that.

(defrelation child (?p ?c) :=     (or (mother ?c ?p) (father ?c ?p)))

Know we say that somebody, called ?c for now, is a child of somebody, called ?p for now, if ?p is the mother of ?c or if ?p is the father of ?c.

Let's define some other relations:

(defrelation son (?p ?c) :=     (and (male ?c) (child ?p ?c))) (defrelation daughter (?p ?c) :=     (and (female ?c) (child ?p ?c)))

A son is a male child. A daughter is a female child.

Now to querying, getting information from the knowledge base. Here are a few queries with their result behind the =>.

(male Fred) => true (female John) => false

That were simple queries that only return true or false. Note that your implementation may display the results in a different way (since I'm not using an interpreter at all (except my brains) while writing this it's kinda logical actually).

(male ?x) => ?x = Fred, ?x = John

Here we ask the system: for each object (known as ?x for now) in the universe of discourse the set which contains every object that exists) that is a male ((male ?x) => true) tell me what the value of ?w is.

Next example, querying with two variables:

(daughter (?x ?y)) => (?x = Alice, ?y = Martha), (?x = Betty, ?y = Alice)

As you can see using two variables also yields the correct result.

Now let's select in queries. Say we want the sister of Fred.

(and (daughter (?x ?y)) (son (?x Fred))) => (?x = Martha, ?y = Alice)

As you can imagine we can program relations out of this:

(defrelation sister (?s ?o) :=     (and (daughter ?x ?y) (child ?y ?o)))

Now to 'bottom'. Sometimes you want to say: this can be anything, but I don't care what it is. KIF supports this through bottom. If you write bottom you're saying: this can be anything, but you will not be informed of what it is. For example: (son bottom ?x) => ?x = Fred, ?x = Pete

In this query we asked for all sons, but not about their parents.

More to follow, when I update this wiki :-).

title: Introspector/KifTutorial


text:
Introspector/Snippets

Here are all statements that are under one line

Interfaces
Introspector interfaces are Import and export routines that allow RDF statements to be extracted from InternalDataStructures? of programs.

We will build interfaces to the following projects for data extraction

[CLanG C] [CPlusPlus C++], ObjectiveC and JavaLang support from the GccProject http://gcc.gnu.org/

[CsharpLang C#], [MicrosoftIntermediateLang MSIL] and other language support via the DotGnuProject http://www.gnu.org/projects/dotgnu/

GnuMake

PerlInternals

ParrotMetaData

M4Language

AutoMake

AutoConf

BashDb

PerlDesignPatterns
http://search.cpan.org/src/SWALTERS/Object-PerlDesignPatterns-0.03/PerlDesignPatterns.html#SingletonPattern

Glade
Glade is just one of the many forms that can be imported into Luxor http://luxor-xul.sourceforge.net/

DataRepository
The data repository will be a distributed RDFServer that stored and indexes the RDFFiles.

The Representation of the knowledge extracted by the introspector is simple : It is a list of identifiers, labels, ids. Things that have a semantic assigned to them, or that may be assigned to semantics. These things are nodes, items, blocks. Basically they are the foundation of knowledge. http://www.burningchrome.com/archives/unrev-ii/msg01818.html

Declaration management
the user should be able to declare new identifiers, replace them, and import and export them from the system

We need ways for users to declare new data structures. The data declarations of the introspector provide a common naming system for all related tools

DataExtraction
we need new tools to extract RDF metdata out of various other systems. We support many different file formats for the introspector. more to come here, TODO : add a table of file formats We need to be able to dump out tabular text files of various names and types in the system. Depends on the QuerySystem? Doxygen like HTML output is important. We will support various XML format inputs and outputs. The main focus is moving towards RDF, because of the power of the rdf notation. But Using RDF to annotate XML trees make sense for representing the object structure.

NTriples
NTriples are even simpler than n3. http://www.w3.org/2001/sw/RDFCore/ntriples/

N3
n3 is a simple rdf alternative notation http://www.w3.org/DesignIssues/Notation3.html See also http://www.w3.org/2000/10/swap/Primer.html

Used Projects
I would like to use the BootLib? http://www.boost.org/

BASHDB
The introspector needs to be accessible from the bash command line.

EMACS
The emacs interface promises many integration tools

RDF
Rdf is a data format that is best described here http://www.w3.org/RDF/ What is Rdf? http://www.xml.com/pub/a/2001/01/24/rdf.html Many people ask, why do you use Rdf instead of Xml.

* Rdf is appropiate for the introspector because of its simple syntax.

* The nodes of the compiler are naturally graphs.

* Rdf allows for information about resources to be added in when it is needed.

* MetaData is naturally stored in RDF.

* Rdf allows for the Ontology and Structure of the data to be added in after the fact.

Redland
I use Redland http://www.redland.opensource.ac.uk/ Redland is a RDF application framework with many SwigLanguageBindings?. http://www.redland.opensource.ac.uk/ We use redland to interface with C modules.

I use Perl http://www.useperl.com/ I use EulerSharp? http://eulersharp.sourceforge.net/2003/03swap/

Ontology
I have posted the first version of the introspector ontology here http://introspector.sourceforge.net/2003/08/16/introspector.n3 please review

Used On Projects
On this node, you can find examples of introspected projects :

Parrot
http://www.nntp.perl.org/group/perl.perl6.internals/14717?show_headers=1

M4
http://mail.gnu.org/archive/html/m4-discuss/2003-01/msg00001.html

Vizualization
The visualization tools will be Built upon the following ToolChain :

* Data Extraction of statements from the subject

* Data filtering of only relevant information from the program

* Breaking down the data set into pages and subgraphs

* Conversion of the statements to nodes and arcs

* emitting of the graph to the graph layout language * invoking of the layout engine

* importing the results of the layout

* creation of a planar graph

* drawing of that graph

* allowing the editing of the graph by the user

* exporting of the graph to other systems.

* saving of the graph data as a resource in the introspector

Code Generators
It should be easy for a user to create new code generators

Graph layout
Graph Layout Tools vcg graphvis tulip xvpodb and more

Dia Interface
Petal2Dia : see this http://mail.gnome.org/archives/dia-list/2002-November/msg00111.html AutoDia is a great module from Arron http://droogs.org/autodia/

title: Introspector/Snippets


text:
Introspector/RDF/Laces

The new RDF::Laces module for Perl is designed to allow the statement of RDF triples in Perl using natural perl expressions. For example, here are the first 2 resources from the Dublin Core, in Perl:

$doc ->dc ->title("The Dublin Core Element Set v1.1 namespace providing access to its content by means of an RDF Schema") ->publisher("The Dublin Core Metadata Initiative") ->description("The Dublin Core Element Set v1.1 namespace provides URIs for the Dublin Core Elements v1.1. Entries are declared using RDF Schema language to support RDF applications.") ->language("English") ->source(           $doc->("http://dublincore.org/documents/dces/"),            $doc->("http://dublincore.org/usage/decisions/")) ->dcterms ->issued("1999-07-02") ->modified("2003-03-24") ->isReferencedBy($doc->("http://www.dublincore.org/documents/2001/10/26/dcmi-namespace/")) ->isRequiredBy($doc->("http://purl.org/dc/terms/")) ->isReferencedBy($doc->("http://purl.org/dc/dcmitype/")) ->{title} ->rdfs ->label("Title") ->comment("A name given to the resource.") ->isDefinedBy($doc) ->dc ->description("Typically, a Title will be a name by which the resource is formally known.") ->type($doc->("http://dublincore.org/usage/documents/principles/#element")) ->dcterms ->issued("1999-07-02") ->modified("2002-10-04") ->hasVersion($doc->("http://dublincore.org/usage/terms/history/#title-004")) ;

The module currently prints out the ntriples for every statement made. More info will be forthcoming, as I'm planning to put it on CPAN.

title: Introspector/RDF/Laces


text:
Introspector/Interfaces/Projects/VCG

VCG is a GraphDrawingProgram. > > From [36]www-data@gnu.org Tue Feb 8 08:15:54 2005 > Return-Path: <[37]www-data@gnu.org> > X-Original-To: [38]novalis-gnu@novalis.org > Delivered-To: [39]novalis@newbabe.mengwong.com > Received: from fencepost.gnu.org (fencepost.gnu.org [199.232.76.164]) > by >      newbabe.mengwong.com (Postfix) with ESMTP id 579D21F524 for >      <[40]novalis-gnu@novalis.org>; Tue,  8 Feb 2005 08:15:54 -0500 (EST) > Received: from monty-python.gnu.org ([199.232.76.173]) by > fencepost.gnu.org >      with esmtp (Exim 4.34) id 1CyVAI-0002Pd-7W for [41]novalis@gnu.org; Tue , > 08 Feb >      2005 08:12:26 -0500 > Received: from Debian-exim by monty-python.gnu.org with spam-scanned > (Exim >      4.34) id 1CyUni-0004Gy-7K for [42]novalis@gnu.org; Tue, 08 Feb 2005 > 07:49:06 >      -0500 > Received: from [199.232.76.167] (helo=rt.gnu.org) by > monty-python.gnu.org >      with esmtp (TLSv1:DES-CBC3-SHA:168) (Exim 4.34) id 1CyUnh-0004GZ-7m; > Tue, >      08 Feb 2005 07:49:05 -0500 > Received: from www-data by rt.gnu.org with local (Exim 4.34) id >      1CyUrX-00075I-FN; Tue, 08 Feb 2005 07:53:03 -0500 > Subject: Re: [gnu.org #220895] Copyright issues with GNUVcg project > From: "Michael Schmidt via RT" <[43]idav@fsf.org> > Reply-To: [44]idav@fsf.org > In-Reply-To:  > Message-ID:  > Precedence: bulk > X-RT-Loop-Prevention: gnu.org > RT-Ticket: gnu.org #220895 > Managed-by: RT 3.0.8 ([45]http://www.bestpractical.com/rt/) > RT-Originator: [46]mschmidt@cs.uni-sb.de > MIME-Version: 1.0 > Content-Type: text/plain; charset="utf-8" > X-RT-Original-Encoding: utf-8 > To: "AdminCc of gnu.org Ticket #220895": ; > Sender: www-data <[47]www-data@gnu.org> > Date: Tue, 08 Feb 2005 07:53:03 -0500 > X-Spam-Status: No, hits=-18.4 required=5.0 >      tests=EMAIL_ATTRIBUTION,IN_REP_TO,QUOTED_EMAIL_TEXT, >      REPLY_WITH_QUOTES,TO_MALFORMED autolearn=ham    version=2.50 > X-Spam-Level: > X-Spam-Checker-Version: SpamAssassin 2.50 (1.173-2003-02-20-exp) > X-Evolution-Source: imap://novalis@newbabe.mengwong.com/ > Content-Transfer-Encoding: 8bit > > > REPLIES GO TO ADMINCCS BY DEFAULT. > >  > > On Fri, 4 Feb 2005, Dave Turner via RT wrote: > > > It sounds to me, from the links that you provide, that version 1.0 > was > > released under the GPL with permission, and with full source code. > Do > > you see any reason that Dupont's version could not be based on > this? > > Hi, > > you mentioned a version "1.0" which I misinterpretated as a typo, but > we discoverd a very old 1.0 package. As far as I can see it contains > not obfuscated source code and a GPL license, i.e. it is a proper GPL > release. As the version number indicates it has more bugs and fewer > features than the obfuscated version 1.3. > > Hence you can use the not obfuscated version 1.0 and the obfuscated > version 1.3 as base for a GPL project. I can also send you a copy of > the package if you do not have it already.

UPDATE !!! this example is taken from the vcg source code http://introspector.sourceforge.net/2003/09/test_adg.c

vcgout.pl vcg rdf extractor : http://introspector.sourceforge.net/2003/09/vcgout.pl

Introspector n3 : http://introspector.sourceforge.net/2003/09/_test_adg.n3

Debian xvcg source : (vcg xvcg xvcg-1.30) http://packages.debian.org/stable/source/vcg

VCG Source : http://introspector.sourceforge.net/2003/09/example_vcg_layout_expr.vcg

Linux PM Bitmap (gziped) http://introspector.sourceforge.net/2003/09/example_vcg_layout_expr.ppm.gz

vcg as a library : http://libvcg.googlecode.com

vcg viewer : http://vcgviewer.googlecode.com

see mail : http://mail.gnome.org/archives/dia-list/2003-February/msg00029.html http://compilers.iecc.com/comparch/article/02-10-057

http://gcc.gnu.org/ml/gcc/2003-02/msg00062.html

Sources : http://introspector.sourceforge.net/debian/incoming/vcg_1.30-4.tar.gz

Debian : http://introspector.sourceforge.net/debian/incoming/vcg_1.30-4_i386.d

-BEGIN PGP SIGNED MESSAGE- Hash: SHA1 Format: 1.7 Date: Sat, 5 Jan 2001 21:38:18 -0100 Source: vcg Binary: vcg Architecture: i386 Version: 1.30-4 Distribution: unstable Urgency: low Maintainer: Malcolm Parsons  Changed-By: James Michael DuPont Description: vcg       - A Visualization Tool for compiler graphs Changes: vcg (1.30-4) unstable; urgency=low .      * removed uglified code Files: 4acf69a83a663d715359b64088db0df9 287684 graphics optional vcg_1.30-4_i386.deb -BEGIN PGP SIGNATURE- Version: GnuPG v1.2.1 (GNU/Linux) iD8DBQE+Pavd7TaNAfoTAloRAraqAJ9IGTrmPQVBzMG6QyZfekzFrRl+rACfdCKr OEIpL8ifinwEviaOudZGHjQ= =CsCG -END PGP SIGNATURE-

title: Introspector/Interfaces/Projects/VCG


text:
Introspector/Interfaces/GUI

The introspector GUI will ideally be a c# windows application.

== Abstract GUI Client ==

The ["Abstract GUI Client"] is a proposed API that will isolate you, the user from a particular GUI toolkit.

It is based on the ["MVC Concept"] which splits things into Model ["MVC/Model"], View ["MVC/View"] and Controller ["MVC/Controller"].

The user looks at the view, and enters data into the controller.

The ["GUI User"] provides events to the ["MVC/Controller Elements"].

The controller is basically a producer of events that are sent to the model. A stream of updates are sent from the controller to to model, and that updates all the views that are watching a particular object.

The ["GUI Application Server"] serves ["MVC/View"] to the ["GUI Client Application"]. The ["GUI Client Application"] displays ["MVC/View"] to the ["GUI User"], and it offers multiple ["MVC/Controller"].

The ["GUI Application Server"] uses ["MVC/Model"] to store ["Application Data"].

The ["Application Data"] is able to be processed by any backend module.

=== RDF Data Architecture ===

The ["MVC/Model"] can be a ["DotGNU/RDF Model"].

The ["DotGNU/RDF Model"] can be composed of ["DotGNU/RDF Graphs"].

The ["DotGNU/RDF Graph"] can be managed on ["DotGNU/RDF Storage Server"].

== See Also ==

* GladeXml

* XulLanguage

* LuXor

* ["Xwt"]

TaskProposal DotGNU RDF Gui
Implement a ["DotGNU"] ["RDF"] ["Gui"] using ["Abstract GUI Client"].

0. Make a GUI that can read one n3 file and find the following things out.

1. Graphical User Interface 1. 1. Find relations between objects 1. 2. Find domains of relations between objects 1. 3. Find types of relations between objects 1. 4. Find cardinality of relations between objects

2. Select Subject/Object 2. 1.  Select Attributes 2. 2.  Select Components 2. 3.  Select Contained Objects 2. 4.  Select Relations

3. Save the relations found as hypothesis in an Ontology

4. Implement as ["Abstract GUI Client"] that Leverages ["GTK#"] ,and ["QT#"]

Status : Proposal

title: Introspector/Interfaces/GUI


text:
Introspector/Introspection

The definition of introspection :

the Introspector is a ModeofMind, a StateOfAwareness. the IntrospectorModeOfMind has a LearningAndInteractiveNature.

The Introspective mind is a read only mode at first, it allows you to see into yourself.

The issues of OntologicalStructure and SymbolicDefinition come ito play when you are Introspecting.

To introspect means literaly to look inside. To spect is to spy, to watch. To externalized your internal ideas into *more* internal forms, but for you mind to see.

This is the ExpansionPredicate, you expand on a symbol, and visualize it.

 * To project internal thoughts onto your visual imagination.

To project images inside the mind.

It is a result of adding one InfQuant to an InternalMentalEvent in the VisualSphere.

an InfQuant is a Quantity of Information

The InternalMentalSymbols, the SymbolDecls, the IconDecls, the GraphDecls that are visualized to the outside world are at first meaningless to a third party.

First via the assignment to a Meaning does a Symbol become valuable. First when they are assigned a meaning via semantics can the value of them be understood.

This process is a stepwise process that involves an human partner that takes part in the introspector use case. Via interfacing with a human, we are able, to extract "meaning" from them.

This meaning is into sentences, an human encoding, an understandable textual form. Sentences allow easy understanding, via direct expression of subject, predicate and object we can indicate the meaning.

Let us look to quotes

http://www.peirce.org/writings/p119.html

When Descartes set about the reconstruction of philosophy, his first step was to    (theoretically) permit scepticism and to        discard the practice of the schoolmen of looking to authority as the ultimate source of truth. That done, he sought a   more natural fountain of true principles, and thought he found it in the human mind; thus passing, in the directest way, from the method of authority to that of apriority, as described in my first paper. :

* Self-consciousness was to furnish us with our fundamental truths, and to decide what was agreeable to reason.

But since, evidently, not all ideas are true, he was led to note, as the first condition of infallibility, that they must be clear. The distinction between an idea seeming clear and really being so, never occurred to him.

Trusting to introspection, as he did, even for a knowledge of external things, why should he question its testimony in respect to the contents of our own minds?

But then, I suppose, seeing men, who seemed to be quite clear and positive, holding opposite opinions upon fundamental principles, he was further led to say that clearness of ideas is not sufficient, but that they need also to be distinct, i.e., to have nothing unclear about them.

What he probably meant by this (for he did not explain himself with precision) was, that they must sustain the test of dialectical examination; that they must not only seem clear at the outset, but that discussion must never be able to bring to light points of obscurity connected with them.

Here is an interesting api that I found into the introspector,it externalizes an model, allowing it to be inspected. http://jade.cselt.it/doc/api/jade/content/onto/Introspector.html#method_detail http://jade.cselt.it/doc/api/jade/content/schema/ObjectSchema.html

Here in the jade object schema, you see that we can add slots to the objects, some manditory, some not, some with cardinality.

Quote from : http://www.quebecoislibre.org/030510-9.htm

For Mises, economic behavior is a special case of human action. He contends that it is through the analysis of the idea of action that the principles of economics can be deduced. Economic theorems are seen as connected to the foundation of    real human purposes. Economics is based on true and evident axioms, arrived at by introspection, concerning the essence of human action. From these axioms, Mises derives logical implications or the truths of economics.

Quote from http://www.gazettenet.com/04222003/entertai/5279.htm

While the spontaneity of these pieces - and others on view at Hampden Gallery - links them to the abstract art created half a century ago, they also are good examples of the lyrical introspection that today's artists bring to their work. Quote from http://www.globeandmail.com/servlet/ArticleNews/TPStory/LAC/20030507/CASUCC/TPBusiness/General

But in his recent book Growing People, Growing Companies he warns that individual career "pathfinding" isn't easy. "Pursuing personal success requires reflection, self-awareness and courage.   The path is difficult to identify, as it is unique to each individual     and has never been found or taken before," he writes. "You are constantly picking your way through virgin forest to create the    route with only the vague feeling that you are     heading in the right direction . . . [it] means     taking risks and experimenting with yourself."

From : http://electroniciraq.net/news/737.shtml

This war (which never really ended – and perhaps has no solidly fixed    beginnings – as is the ephemeral nature of     slow-drip genocide) has shattered communities and served as     a grand example of a massive setback for humanity.

It has also highlighted a whole plethora of issues that the West tries to ignore as we rush into condemnation of the more blatantly visible players.

We – the alternative – in our finger pointing, our doling out of blame to the figureheads, the passing array of   politicians "responsible" for how far astray the human race has gone, have somehow missed one of the lessons so blatantly obvious in all of this:

that introspection and reflection, and admission of our own complicity within this, is vitally important if we are to      move forward with any sort of cohesion as a movement.

That in the "shaming," in the blaming of the other (who really aren’t like us at all, because we care), perhaps we should be saying shame, too, on us – for twelve years of not managing to    break the sound barrier; shame for the suffocating silence surrounding genocidal sanctions; shame for every victim of Israeli apartheid in occupied Palestine;shame for the slow and painful or quick deaths and the lives never given voice, never fought for, never honored; shame for every victim of state-sponsored terrorism; and shame for the memory of    every Iraqi man, woman and child who lived with a virtual gun to their heads for far too long.

Quote from http://ontology.buffalo.edu/smith//articles/mach/mach.html

But there is another, one might almost say phenomenological, aspect to his thinking. All Mach's arguments, however they are to be classified, are rigorously subordinated by him to a single goal: the goal of increasing knowledge.(19) He is   quite prepared to renounce any claim to the epithets 'physicist' or 'philosopher' if      this contributes to the advancement of our understanding of the world ((1910), p. 11). He thereby stands in marked contrast to those philosophers and scientists who are all too ready to impose in advance requirements that enquiry has to satisfy if it is to be    'scientific', for example by foisting abstract 'criteria of rationality' on live traditions of research.

He shares with Husserl and others in the Brentano tradition the conviction that theoretical enquiry cannot afford to lose sight of the origins of our ideas (scientific and otherwise). Scientific ideas, as Mach conceives them, must have their origins in concepts - called by him 'inaugurating concepts' - derived directly from experience (and, like the    phenomenologists, Mach was prepared to acknowledge the role played by introspection      in the foundations of scientific     enquiry). The science of heat, he argues, is derived from the concept of felt warmth, the science of light from the concept of intensity of illumination, the science of acoustics from the concept of frequency, and so on.(20)

Mach shares with members of the phenomenological tradition a conception of the philosophy of science as something that must be tied to the actual practice of science. As Husserl puts it: 'A fruitful theory of concept formation in the natural sciences can...only be a theory "from below", a theory that has grown out of     the work of the natural sciences themselves.' The passage occurs in the context of a discussion by Husserl of a     monograph by the Neo-Kantian Rickert in     which a conception of the philosophy of science is manifested 'which deals so      much in general constructions, is so much a    theory "from above", that not a single example is to be found in the entire monograph and nor does this absence make itself felt' (1979, p. 147). It is a recurring feature of Mach's deservedly famous conceptual analyses of the ontological commitments of scientists e.g. to space and time, that he proceeds by gradually stripping away from these all purely conceptual baggage, all metaphysical free play not directly related to sense experience - and thereby arrives, step by step, at certain (as Mach    conceives things) unambiguous and precise components, such as the inaugurating concepts mentioned above: I see the expression of... economy clearly in the gradual reduction of the statical laws of machines to a single one, viz., the principle of virtual work: in the replacement of Kepler's laws by     Newton's single law... and in the [subsequent] reduction, simplification and clarification of the laws of dynamics. I see clearly the biologico-economical adaptation of ideas, which takes place by the principles of continuity (permanence) and of adequate definition and splits the concept 'heat' into the two concepts of 'temperature' and 'quantity of heat'; and I see how the concept 'quantity of   heat' leads on to 'latent heat', and to the concepts of 'energy' and 'entropy'. ((1910), p. 6f.)

See also PrinciplesOfVirtualWork PrinciplesOfContinuity

Quote from http://www.acooke.org/andrew/writing/lang.html

In many OO languages it is possible to find out what class an object is     (run time type information) and even what functions are connected with it (introspection / reflection). Others, like C++ have little run time information available (at least in the standard language - individual libraries     of objects can support RTTI  with their own    conventions).

from : http://www.singinst.org/LOGI/seedAI.html

Better support for introspective perception and manipulation. The comparatively poor support of the human architecture for low-level introspection is most apparent in the extreme case of modifying code; we can think thoughts about thoughts, but not thoughts about individual neurons. However, other cross-level introspections are also closed to us. We lack the ability to introspect on : * concept kernels, * focus-of-attention allocation, * sequiturs in the thought process, * memory formation, * skill reinforcement, et cetera; We lack the ability to : * introspectively notice, * induce beliefs about, * or take deliberate actions in these domains.

More to come.....

title: Introspector/Introspection


text:
Adventist Youth Honors Answer Book/Household Arts/Nutrition - Advanced

1. Have the Nutrition Honor.
Answers to the Nutrition Honor can be found in the Household Arts chapter of this book.

2. Read a book about Nutrition.
Suggested books include:
 * Foods for Thought: Nutrition's Link to Mood, Memory, Learning and Behavior Bernell Baldwin, Vicki Griffin, Evelyn Kissinger, Review and Herald, 152 pages.
 * An Ounce of Prevention: Your Pathway to Abundant Health, Review and Herald, 64 pages.
 * Counsels on Diet and Foods Ellen G. White, Review and Herald, 512 pages.
 * Dynamic Living Hans Diehl, Dr.H.Sc., Aileen Ludington, M.D., Review and Herald, 208 pages.
 * Foods that Heal George D. Pamplona-Roger, M.D., Review and Herald, 94 pages.

3. Keep a food diary on yourself for one week.
This can be done with pencil and paper or with an online tool such as the one provided by the USDA at ChooseMyPlate.gov.

4. Calculate the total nutrients of the following in your diet each day

 * a. Calories
 * b. Protein
 * c. Iron
 * d. Calcium
 * e. Vitamin A
 * f. Thiamine
 * g. Riboflavin
 * h. Niacin
 * i. Vitamin C or ascorbic acid

If you have access to the Internet, you can visit the USDA's ChooseMyPlate.gov web site. Once you register, you can enter all the foods you eat in a day, and it will analyze your nutrient intake (among other things) based on this information. ChooseMyPlate can retain the information you enter for up to a year, so tracking it for a week will be easy.

If your Pathfinders do not have access to the Internet, have them record their diets on paper. You can then use the website to extract the necessary data by entering each food individually, or you can find a cookbook that has nutrient values of various foods in an appendix. Another option would be to meet in a place that has public Internet access, such as a library or Internet cafe. Then your Pathfinders can enter the data they have collected for a week and analyze it there.

5. How do the number of nutrients in your diet compare with the Recommended Daily Allowance chart?
The USDA's ChooseMyPlate.gov web site will compare your nutrient intake with the RDA chart.

6. Explain why a high fiber diet is important, and tell how this can be obtained.
Fiber promotes the wavelike contractions that keep food moving through the intestine. Also, high-fiber foods expand the inside walls of the colon. This eases the passage of waste. Fibrous substances pass through the intestine undigested. They also absorb many times their weight in water, resulting in softer, bulkier stools. Insoluble fiber is found in wheat, rye, bran, and other grains. It is also the fiber found in most vegetables. See

Scurvy
Scurvy is a disease that results from insufficient intake of vitamin C and leads to the formation of livid spots on the skin, spongy gums, and bleeding from almost all mucous membranes. The spots are most abundant on the thighs and legs, and a person with the ailment looks pale, feels depressed, and is partially immobilized. Scurvy was at one time common among sailors whose ships were out to sea longer than perishable fruits and vegetables could be stored and by soldiers who were similarly separated from these foods for extended periods.

Beriberi
Beriberi is a nervous system ailment caused by a deficiency of vitamin B1 (thiamine), the symptoms of which may include weight loss, emotional disturbances, impaired sensory perception, weakness and pain in the limbs, and periods of irregular heartbeat. Swelling of bodily tissues is common. In advanced cases, the disease may cause heart failure and death. The origin of the word is from the Sinhalese (Sri Lankan) language meaning "I cannot, I cannot".

Beriberi occurs in people whose staple diet consists mainly of polished white rice, which contains little or no thiamine. Therefore the disease has been seen traditionally in people in Asian countries (especially in the nineteenth century and before) and in chronic alcoholics with impaired liver function. If a baby is fed the milk of a mother who suffers from a deficiency in thiamine, the child may develop beriberi.

Rickets
Rickets is a disorder which most commonly relates directly to Vitamin D deficiency, which causes a lack of calcium being absorbed. It can also arise, however, from other causes such as certain types of rare tumors or any phosphate-wasting disease. Because calcium is an essential nutrient which aids bone rigidity, the lack of it being absorbed into the body causes fragile or malformed bones, which are unable to support the weight of a growing body. Rickets causes bone pain, slowed growth in children, dental problems, muscle loss and increased risk of fractures (easily broken bones).

Pellagra
Pellagra is a vitamin deficiency disease caused by dietary lack of niacin and protein, especially the essential amino acid tryptophan. Symptoms of pellagra are red skin lesions, diarrhea, dermatitis, weakness, mental confusion, and eventually dementia. This disease can be common for persons who obtain most of their food energy from corn, as corn is a poor source of tryptophan. Therefore this disease can be common amongst people who live in rural South America where — during winter — they live on corn. Usually the symptoms show during spring, and disappear over summer, to return the next spring, after another long winter.

8. What are the symptoms of vitamin B12 deficiency?
Early, noticeable symptoms of Overt B12 Deficiency: Unusual fatigue, faulty digestion, no appetite, nausea, loss of menstruation. Also numbness and tingling of the hands and feet, nervousness, diarrhea, mild depression,etc. See

9. What advice would you give a person who decided to be a total vegetarian?
http://philipngcc.homestead.com/

http://www.dietobio.com/dossiers/en/vegetarism/index.html

http://www.giveusahome.co.uk/articles/vegetarianism.htm

Because Vitamin B12 cannot be obtained through plant sources, total vegetarians are advised to eat foods with B12 added (such as fortified soy milk, fortified margarines, or many commercial breakfast cereals), certain brands of nutritional yeast, or take dietary supplements (a good multivitamin will likely include B12 in sufficient quantities).

10. What is the difference between saturated and unsaturated fats? Which is the most healthful, and why?
Saturated fats and trans fatty acids are the kinds of fats most likely to cause heart disease. Saturated fats are found mainly in animal products (eggs, butter, cheese, whole milk, and whole milk products), and in coconut, palm, and palm kernel oil. Trans fatty acids appear in foods containing hydrogenated fats like margarine and crackers. To reduce the risk of heart disease, replace saturated fats with unsaturated fats like canola oil, olive oil, flax seed oil, nuts, avocado, soy products, and nut butters. Choose margarine, cookies, crackers, and snack foods that do not contain hydrogenated fats (read the label). See

11. Why is it advisable to use less sugar in the diet? List several ways in which this may be accomplished.
There are a several reasons why sugar is ruining your health: Sugar can suppress the immune system; Sugar leads to cancer of the ovaries; Sugar can cause heart disease; Sugar can cause appendicitis; Sugar can cause multiple sclerosis; Sugar can increase cholesterol; Sugar can increase the systolic blood pressure; Sugar can cause drowsiness and decreased activity in children; Sugar can contribute to Alzheimer’s disease; Sugar can lead to prostate cancer; Sugar can cause liver tumors; etc.

Several ways to use less sugar: Cut down slowly; go half and half; establish rules about dessert; If you must eat sweets, eat them with meals; Choose the right breakfast cereal; Don't skip meals; Don't add sugar to foods; ot for a walk when you crave sweetness; Go fat-free if you must have sweets.

==12. What are amino acids? How many are needed to make all the proteins in the body? What is meant by essential amino acids? How many of them are essential? Where can you get all the essential amino acids?== Note: http://www.google.com enter definition essential amino acids to get this and other related definitions!
 * Definition of Essential Amino acids: the nine a-amino acids required for protein synthesis that cannot be synthesized by humans and must be obtained in the diet: histidine, isoleucine, leucine, lysine, methionine, phenylalanine, threonine, tryptophan, and valine.

Of the 28 amino acids needed by humans, 9 of them cannot be manufactured by the body and are thus termed "essential."

Only some foods contain all the essential amino acids. These are: milk and dairy products, eggs, fish, meat and poultry. If you don't eat animal products, the only way you can get all the essential amino acids is by combining plant foods. For example: corn plus peas or beans, rice plus beans, lentils plus bread. Google results:

Another term that comes up when we talk about protein nutrition is the term essential amino acid. Our bodies can make quite a number of amino acids from other chemicals that are contained in the body and can convert some amino acids into other amino acids. However, there are some amino acids we are not able to synthesize ourselves. Those particular amino acids and they must be provided to us in our diet. Those amino acids are referred to as the essential amino acids. It's not to say that the non-essential amino acids are not necessary, it's just that it is not necessary for them to be in our diet because other things in the diet can be used to make them.

13. Know the difference between water and fat soluble vitamins. What are two common vitamins that are fat soluble? What are two vitamins that are water soluble?
The fat soluble vitamins are soluble in lipids (fats). These vitamins are usually absorbed in fat globules (called chylomicrons) that travel through the lymphatic system of the small intestines and into the general blood circulation within the body. These fat soluble vitamins, especially vitamins A and E, are then stored in body tissues. Two common vitamins that are fat soluble (A, D, E, and K). Two vitamins that are water soluble (B and C). It determines how each vitamin acts within the body.

14. Using the book Counsels on Diet and Foods by Ellen G. White, write a paragraph on the benefits of a lacto-ovo vegetarian diet.
Use the "search the writings" feature on http://www.egwestate.org


text:
User:Yellice

Welcome to Yellice page

title: User:Yellice


text:
Budget Watch Collecting/Automatic Winding

The basic prinicple of most automatic winding systems is simple. The rotor is a relatively large unbalanced weight mounted in a way that it can turn around a pivot. As the watch moves, the rotor will shift around the pivot. The rotor is indirectly connected to the mainspring arbor in a way that causes the mainspring to be wound slightly when the rotor moves. In some watches, only movement in one direction will wind, with bidirectional winding every motion of the rotor helps wind.

Auto Winding Systems
Seiko most often uses the Magic Lever system, an extremely simple yet effective system, requiring only 3 or 4 more parts than a manual wind watch. A gear with ratchet teeth is placed so it's pinion meshes with the mainspring winding gear. The magic lever is a V shaped metal lever with flexible legs. The open end of the V is placed around the ratchet gear--one end has a hook, the other an angled point. When the magic lever moves away from the ratchet wheel, the hook pulls the wheel in the winding direction. When the magic lever moves towards the ratchet wheel, the point pushes the wheel in the winding direction. The base of the V is attached to an eccentric post, either part of the rotor or a secondary wheel driven by the rotor.

Timex used a more complex version of this system in their automatics. In the Timex system the equivalent to the Magic Lever was made of several pieces with pivots and springs, and the ratchet wheel had planetary reduction gears to increase leverage enough to wind the spring. In both of these systems, the ratchet wheel can turn without turning the rotor, allowing handwinding with no decoupling wheel needed, although many Seiko automatics do not provide handwinding capability.

Many ETA movements use reversing wheels. In this system, there are two sets of gears, each with a top and bottom gear connected by a one-way clutch. One top gear will be driven by the rotor and will in turn drive the other top gear. Both bottom gears are connected (directly or indirectly) to the mainspring arbor. When the first gear is turning in the direction that it can wind the watch, it's associated bottom gear will also turn with it, winding it. The first gear will also turn the second gear in the opposite direction. The second gear's one-way clutch will allow the bottom gear to disconnect. When the first gear moves in the wrong direction for it to wind, it's bottom gear will be allowed to disconnect, but it will be turning the second gear in the opposite direction, allowing it to wind the watch.

The rocker bar system has two gears (usually called wheels) meshed together on a pivoting rocker bar, and will be driven by a gear when the rotor turns. In this description, assume that the rocker bar is to the right of the driving gear, and the driven gear is above the rocker. When the driving wheel turns counterclockwise, the rocker will rock slightly clockwise, so that the rocker gear meshing with the driving gear will also mesh with the driven gear, turning the driven gear counterclockwise. When the driving wheel turns clockwise, it will cause the rocker to pivot slightly. The rocker gear meshed with the driving gear will move down and away from the driven gear, while the opposite rocker gear will move upwards and mesh with the driven gear, again causing the driven wheel to turn clockwise.

Most rocker-bar systems have handwinding capability, this requires a decoupling wheel so the rotor is not forced to turn with handwinding.

All of the above watches have 360 degree rotating rotors. An earlier form of automatic wind is the bumper-wind. In these, the rotor could not make a full rotation--Instead, at the ends of its allowed travel it would hit springs. These were produced until the patents for the 360 degree rotor expired.


text:
File:Flamengo Logo.jpg

Summary
Flamengo logo.

Licensing
/Logos

title: File:Flamengo Logo.jpg


text:
File:Corinthians Logo.gif

Summary
Corinthians logo.

Licensing
/Logos

title: File:Corinthians Logo.gif


text:
File:Palmeiras Logo.gif

Summary
Palmeiras logo.

Licensing
/Logos

title: File:Palmeiras Logo.gif


text:
File:Santos Logo.gif

Summary
Santos (Brazilian) logo.

Licensing
/Logos

title: File:Santos Logo.gif


text:
File:Sao Paulo Logo.gif

Summary
São Paulo logo.

Licensing
/Logos

title: File:Sao Paulo Logo.gif


text:
Talk:Electrodynamics/Four-Vectors

when i get some time i promise i'll revamp this page, but all i can say is wow this sucks thus far, so someone with a bit of time on their hands please help!

title: Talk:Electrodynamics/Four-Vectors


text:
Biblical Studies/Christianity/Christianity and the world's religions

This title speaks volumes: Christianity and the world's religions, the suggestion that Christianity is different from World Religions. It is. Fundamentally different, in its focus. The focus is on the person of Christ. This Jesus Christ who came to Earth to offer man salvation. A salvation not based on goodness, moral teaching or good behaviour. It is based not on Jesus's great teaching, which most acknowledge as sound, but on his work on the cross.

No religion offers the believer perfect salvation. Others offer good codes, practices, rituals, teachings and wisdom. But none offer God himself, present in the believer's life through the Holy Spirit of God. Some offer an approach to God, through prophets or good teachers. However the eternal concept of "Christ in me," the hope of glory, is alien, to other religions.

There is much to write on the differences between the religions of this world.


text:
Consciousness Studies/Print version

= Table of contents =

=Introduction=
 * Introduction

In some aspects, we know more about the history and evolution of the universe, our planet earth, its geology, and evolution of our present Homo Sapien physical characteristics, the external existential 'world', than we do about our own minds and nature of our consciousness. Modern medical brain studies tell us about brain functions, but we have yet to definitively understand the 'mind' and our thoughts. At least in the West. But, if we look Eastward to Asia, we will find a long tradition of investigation, theories, and 'findings' about human consciousness. ... incomplete as of September 2017. e

=Historical review=
 * Early ideas

We know that a variety of humanoids inhabited this earth before our current Homo Sapiens variety. How we came to be the only surviving one is another story.

Besides skeletal remains, and early tool and living instruments remnants, we catch early glimpses of our ancestors in cave drawings.

 * Seventeenth and eighteenth century philosophy
 * Nineteenth to twenty first century philosophy

=Questions of consciousness=
 * What needs to be explained: the description and definition of consciousness
 * The conflict - where, when and what?
 * The regression argument
 * The subject-object paradox
 * The homunculus argument
 * Phenomenal consciousness and access consciousness
 * Direct Realism
 * Indirect Realism
 * Dualism
 * Idealism
 * Panpsychism

 * Breaking down the philosophical and scientific problems
 * The philosophical problem
 * Epiphenomenalism and the problem of change
 * The problem of time
 * The problem of space
 * The problem of qualia
 * Elementary Information and Information Systems Theory
 * Classification, signs, sense, relations, supervenience etc. | Classification, signs, sense, relations, supervenience etc.
 * Qualia and Information
 * Absent and fading qualia
 * Putnam's twin earth thought experiment
 * The Inverted Qualia Argument
 * The Knowledge Argument
 * The problem of machine and digital consciousness
 * Measurement in physics and the preferred basis problem

=Neuroscience of consciousness=
 * The neuroscience of consciousness
 * Introduction
 * The substrate of experience
 * Neuroanatomy
 * The neurophysiology of sensation and perception
 * Vision
 * The cortex and thalamus
 * The cortex and consciousness
 * Perception, Imagination, Memory and Dreams
 * More about Models
 * Blindsight
 * The Role of the Thalamus
 * General Anaesthesia and the Thalamus
 * The function of consciousness
 * Rivalries and synchronisation
 * Binocular Rivalry, Pattern Rivalry and Binocular Fusion
 * Synchronisation of Neural Processes
 * EEG and synchronisation
 * Global Workspace Theory
 * Behaviourism and consciousness
 * Models of access consciousness
 * Neural networks

=Contemporary explanations of consciousness=

 * Contemporary explanations of consciousness
 * The identity theory of mind
 * Scientific theories
 * Functionalism
 * Dualism
 * Intentionalism
 * Higher order thought
 * Eliminativism
 * Mysterianism
 * Idealism and panpsychism

=Other explanations of consciousness=

 * Consciousness-only
 * BioPsychoSociology Model 1 BPS Model

=Appendices=

Some physical science for consciousness studies:
 * Ontology of Newtonian physics: kinetic energy and magnetism
 * The origin of the metric tensor
 * Action, Lagrangian and Hamiltonian Mechanics

=Introduction=

=Historical Ideas=

=Defining the Problem=

=The Philosophy of Consciousness=

= The Neuroscience of Consciousness =

=The neurophysiology of sensation and perception=

=The Cortex and Thalamus=

=Rivalries, Synchronisation and Workspaces=

=Behaviourism and Consciousness=

=Models of Access Consciousness=

=Contemporary Explanations of Consciousness=

=Scientific Theories of Consciousness=

=Other Explanations=

=Conscousness only=

=Bps model=

=The Ontology of Physics=

=The Origin of the Metric Tensor=

title: Consciousness Studies/Print version


text:
Talk:Myers-Briggs Type Indicator/QuickTyping

Just learning WikiBooks. I felt it important to give proper attributes to Speedreading(QuickTyping) in fact, I cannot find an original source for QuickType, and the Tieger work, which stems originally from the 80's, fully develops the same three-fold process.

I will figure out how to the citation, but just so as to not lose it, it is:

Paul D. Tieger and Barbara Barron-Tieger, The Art of Speedreading People: Harness the Power of Personality Type and Create What You Want in Business and in Life (Hardcover) Hardcover: 208 pages Publisher: Little Brown & Co (T); 1st ed edition (February 1, 1998) Language: English ISBN: 0316845256


text:
Biblical Studies/Christianity/Christian Theology/Immutability

I AM THE LORD AND I DO NOT CHANGE

God is bold enough to declare this simple statement, I AM. Together with this statement that "I do not change". This declaration is a majestic proclamation that God, whoever he is, does not change. If he is good, then that goodness never changes. Whatever his attributes, like mercy and justice, those do not change. Ever. This is the Doctrine of Immutability. God is Lord and he does not change.

If one is to believe in a God, it is essential that he is immutable. Faith is based on the trust that God says who he is. God must therefore be immutable for the Bible to be true. For the prophecies and the promises to be of any value, God must be the ultimate being. He must be who he has always been. Otherwise everything that faith calls for needs to change.

If God makes a promise then he must be capable of fulfilling his word. Also he must be trusted to deliver on his promise. Trusting God is by definition believing in his unchanging nature.

Changing is something humans have to do to regain their status before the fall of man. God is perfect, therefore does not need to change. Immutability and perfection are connected. If one is perfect then change is not required. The Bible teaches that God never changes. The promises are unchanging. God boldly declared in Malachi 3:6 that he is unchanging. The immutability of God is thus certain and an essential part of the doctrine of Christianity.