text:
Talk:Biblical Studies/Christianity/Roman Catholicism/Prayers and Sacramentals

If page should be renamed, fix it. JBogdan 16:53, 10 September 2006 (UTC)


text:
Biblical Studies/Christianity/Roman Catholicism/Other Topics

Saints
The pope beatifies and canonizes certain individuals who have led a life of heroic example. Recent canonizations and beatifications are documented on the Vatican website.

Vatican City
Vatican City State is an independent nation where the pope resides. Saint Peter's Basilica and many of the papal offices are located in Vatican City State. Vatican City State is approximately 108 acres inside the city of Rome, Italy. Included in the nation are several non-adjacent basilicas and the pope's summer residence.

Ecumenical Councils
Currently there have been only twenty-one Ecumenical Councils. They were: First Council of Nicaea; First Council of Constantinople; Council of Ephesus; Council of Chalcedon; Second Council of Constantinople; Third Council of Constantinople; Second Council of Nicaea; Fourth Council of Constantinople; First Lateran Council; Second Lateran Council; Third Lateran Council; Fourth Lateran Council; First Council of Lyon; Second Council of Lyon; Council of Vienne; Council of Constance; Council of Basel, Ferrara, and Florence; Fifth Lateran Council; Council of Trent; First Vatican Council; Second Vatican Council.

An ecumenical council's decrees do not have an obligatory force unless they have been approved by both the council fathers and the pontiff, and the pontiff has ordered the decrees to be promulgated.

The Evangelical Counsels
The evangelical counsels are poverty, chastity, and obedience. Priests in a religious order take vows to observe all three; diocesan priests take vows of only chastity and obedience. Although not an evangelical counsel, the Jesuits also take a fourth vow of obedience to the Pope regarding assignments.

Religious orders
Some major religious orders are the Dominicans, Franciscans, Jesuits, Trappists, Benedictines, Augustinians, and Carmelites. There are many more religious orders of many sizes, some of which are derived from another order.

The Code of Canon Law
The Code of Canon Law is a law code used in the Church's administration. The current version is available on the Vatican's website.

The Seven Gifts of the Holy Spirit
The seven gifts of the Holy Spirit are: Wisdom, Understanding, Counsel, Fortitude, Knowledge, Piety, and Fear of the Lord.

The Twelve Fruits of the Holy Spirit
The Twelve Fruits of the Holy Spirit are: Charity, Joy, Peace, Patience, Kindness, Goodness, Generosity, Gentleness, Faithfulness, Modesty, Self-control, Chastity.

The Four Last Things
The Four Last things are: Death, Judgement, Heaven, and Hell.

Marian Images

 * Saint Juan Diego's Tilma (image of Our Lady of Guadalupe)
 * The Black Madonna of Częstochowa

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


text:
User:E A Tarina

find me on wikipedia instead E A Tarina

title: User:E A Tarina


text:
How to Write a Program/Collected Real-life Experiences

Why this book
Good practices and life experiences are never captured in books. Most computer science books are API walk-through. This book is DIFFERENT!

Build scripts
Try to set up "one-button testing". That makes it much more convenient to type a little, then hit that button which
 * saves the file you just edited,
 * compiles the application with all the appropriate options (such as "-fno-emit-frame", if necessary), and
 * runs a few quick tests, to make sure your "improvements" don't accidentally break something else.

Spending an hour to code up a few tests and set up one-button testing may *seem* like it is more hassle than it is worth. Manually compiling the file, and manually run through the various parts of the application to make sure they work, may take far less than an hour. But trust me, most programs you are going to edit-compile-test many, many times. And a year from now, when you make just one tiny little change, wouldn't you much rather push-the-button and be done with it, rather than
 * manually compile the file
 * manually run through the application and see that it suddenly it doesn't work any more
 * pull out your hair until
 * hours later, you remember you needed to include "-fno-emit-frame"
 * manually re-compile the file, this time with "-fno-emit-frame"
 * start testing all over from the beginning.

There are lots of ways to set up an automated build system.

One-button testing is just one part of the continuous integration recommended by some programmers.

Even lawyers can see the advantages of automated build scripts.

Scripting in general
This shouldn't just apply to build scripts. If you ever find yourself repeating a few lines, throw it into a script or batch file.

Learning to use Cygwin bash scripts if you are a windows programmer is often worth while. They are much more flexible than windows batch files. Also look into AutoHotKey.

For that matter, don't be afraid to build yourself tools of any sort! You are a programmer, if you are working with a lot of metadata, make a metadata editor. If your build file has too many options to remember and they change a lot, write a GUI for it. Every step you can skip is one step you can't screw up--and a single screw-up can cost as much time as it took you to build your script or tool.

Another reason for scripts and tools is knowledge retention/exchange. You can tell a co-worker how to do the build 4 times until he remembers each step, or you can hand him the script that you use. Ftorkou besaha

Concurrency issues
Don't use table locking! Its flawed! Use Transactions, in JDBC set the isolationlevel of the connection.

Error handling
Always remember to use the finally block for closing resources! Otherwise exceptions being thrown may result in many open connections

Be careful with empty error handlers... Error handles should NEVER be empty, but this is hard to enforce in Java because of checked exceptions. For instance, Java's sleep method throws a checked exception so you MUST catch it. Very few people actually use this and don't care, so they wrap it with an empty handler. Because of this, checked exceptions are considered an anti-pattern or just broken.

It is extremely difficult to track down bugs when the stack trace was hidden because someone thought they were "Unimportant" or messy, or someone else caught too broad an exception and hid the trace that would have made your bugfix a piece of cake.

Error tracking
Whenever you output anything as an error message, prefix it with e.g. new Date  or similar so you are able to track back later on. Adding the module name to the error message is also useful. Try to build your error handling as part of your testability. Don't rely only on the debugger to find your code errors.

Your time is well spent setting up a logging framework such as Log4J. Do note that certain configurations of the logging software are not suitable for production code due to the efficiency loss during the logging functionality. Do some iterative testing of various setting combinations to get an idea of the speed loss, then decide on the optimal combination to use.

Time Yourself
Many programmers are awful at estimating how long adding some feature to a program will take. Practice, practice, practice. Even if no one asks you how long it will take, keep a personal log of when you started adding that feature, when you (estimate) you will be finished, and when you (actually) finished. Even if you have totally no idea, at least write down when you started and when you stopped. Every time, you will learn something new about how long it takes to do that sort of task.

Comments!
It is amazing how many programmers will just NOT write comments, no matter how many different sets of coding standards recommend (or even mandate) that code be properly commented.

Comments are extremely important to the maintenance phases of a software project. Anyone who has been required to analyze, modify, or maintain someone else's code will attest to the fact that without comments the job requires much more effort, time, and money than to do the same task on properly commented code. Don't forget that you may, yourself, end up being responsible for this task at some (much) later date.

It is just as important not to over-comment as it is not to under-comment. Adding comments to the end of every line of code is total overkill. Instead, assume the reader has some familiarity with the language, and restrict the comments to descriptions of the functionality of a block of code.

Whenever you are looking at code (even your own) if you have the slightest trouble understanding it, it needs commenting. If you have a lot of trouble understanding it, it needs refactoring.

You may find it more comfortable to comment code once you are done coding a method — go back to the top and walk through each step. This also forces a small review of the code. Commenting before you code is also good — create a basic flow in comments first then insert code between the comments. Just don't forget to sanity-check your comments when you are done, often I'll only have a few of my original comments left when I'm done.

Another important concept is "self-documenting code". This means you use the names of functions, variables, classes, and methods to communicate the ideas of your code so that you don't have to write many comments. If you name a method with the action it performs, it will be evident to the reader what it is going to do; for example, use a method named  rather than just doing a comparison such as.

Don't neglect file headers in the code modules. These are important to provide a synopsis of the operation of the code, as well as authoring and licensing information. Most editor programs open code modules with line one of the file at the top of the screen; making the top section of the file contain a block comment which specifies what that module does is very helpful during maintenance.

Commenting is not a difficult discipline to master; in fact, it is quite easy to create a set of templates with standard comment forms for several languages, then copy the template and add in the code and appropriate comment details when starting a new module. Several Integrated Development Environment tools, such as Eclipse or X-Code, can be configured to do this automagically when a new source file is created.

Finally, it may be helpful on a medium- to large-scale project to use an automated documentation tool, such as Doxygen, JavaDocs, or Autodoc, to create hypertext-linked documentation for the modules in the project. This provides all the members of the project with the same standard documentation so that everyone can know the availability and operational details of all code modules in the project.

To get a good idea of some usable code-based documents, check out the Java source code in the libraries. Each Class has a comment block showing general class usage, each external method has a comment block describing usage and gotchas, and each non-trivial method has inline (non-javadoc) comments describing what is going on for each block of code (often for each line). Over all there are probably 5-10 lines of comments per line of code, but the method comments are more verbose than needed unless you are building a library for public use.

(The other thing you'll notice when reading through Sun's source code is that most methods have 1-3 lines. Good OO design looks like "Magic"--you think there must be a huge routine laying around somewhere doing all the "Real Work", but you never see it, it's just these little 1-3 line routines all the way to the center.)

If you are slowed down by typing comments (even 3 lines of comments per line of code) you are ether severely in need of a typing class or you are typing faster than you are thinking! Please take time with your code--don't just slam something out, check it in and go to the next. Review and rewrite comments as you refactor your first pass of code. You may think you are doing what your boss wants by slamming out code changes and bugfixes as fast as you can type, but what you are actually doing is (in my experience) getting your entire team fired due to extreme bug count and maintainability problems.

Configuration Management
Configuration Management, also known as "CM" (or sometimes "SCM" for "Software CM"), is a very misunderstood topic. Although there is some change in attitude happening lately, the prevalent thinking seems to be that CM is a "necessary evil", to be tolerated but not actively participated in, at least not more than absolutely required.

Change is unavoidable when computer software is constructed, and change increases the level of confusion among the developers who are working on the project. Confusion arises when the modifications are not analyzed before they are performed, written down before they are made, controlled in a way that improves quality and reduces mistakes, or properly reported to the people that should be aware of them.

There are several reasons for changes being required. First, the customer may levy one or more new requirements, or may make requests to change existing requirements. This can be driven by design reviews, re-engineering of applications, or even schedule and budgetary constraints. Second, changes in business conditions or the market for the application may direct that changes are required. Third, the business environment may grow or change, which may change the project priorities or the structure of the customer or supplier engineering team. The thing to remember is that as time goes on, all stakeholders come to know the system more intimately; this increase in knowledge is what drives the great majority of the requested/required modifications to the software. Thus it is a fact, which many software engineers and project managers have a hard time accepting, that most changes to software are justified!

Configuration management deals with the multi-version features of a software engineering project. CM is a set of activities that have been developed to assist in management of the changes that occur throughout the life cycle of the software project. In a typical project, the deliverable system comprises many different files and directories, and many complex relationships may develop between them. The problem is exacerbated by the need for frequent modifications during the development. The end results of poor CM include:

 * Finding/fixing the same error multiple times (inconsistency between versions)
 * Inconsistency between documentation and code
 * Loss of documentation
 * Loss of code

In a software system, a configuration includes all the "work products" associated with the system. This means not only the system that is actually delivered to the customer, but also the documentation and support code maintained by the developer. A configuration may also include different versions of executable files for different platforms, and may have associated defects and tasks that govern the assignment of modules to the members of the programming team.

To understand the problems connected with CM, it is important to grasp the enormous number of objects that are part of a characteristic software project. Even a small-sized system may contain more than a hundred files. For realistically-sized systems, this number may grow to thousands or even tens of thousands. Problems associated with CM can be similar in scope to the ones faced by a modern library. Without careful inventory controls, many of the books in the library would be misplaced, mis-shelved, stolen, or even lost.

Another thing to remember is that an effective CM plan is part of any software development effort that claims to adhere to the principles of Capability Maturity Model® Integration (CMMI). This system, created by the Software Engineering Institute (SEI) at Carnegie Mellon University, provides a process improvement approach to software development. It has 5 levels, the top three of which all include some sort of documented CM process.

CVS/Subversion
Subversion (SVN) seems to have surpassed CVS in functionality (see TortoiseSVN). However, CVS has a quite nice interface WinCVS.

Optimizations
You may have heard that "Premature optimizations are the root of all evil". It is true. I suggest you follow these guidelines.

 * Always write unoptimized code first.
 * If your application is too slow, run an analyzer to figure out just where.
 * Re-write the indicated code to be more optimized, but keep the old code in a comment.
 * RETEST and if your application is not noticeably faster, rip out the optimization.

Note, this is not an excuse for ignorance! As a programmer you MUST understand basic concepts like if you are doing an insertion sort, choose a linked-list over an array! This is not an optimization, it's programming!

See Optimizing Code for Speed for many ways to make programs run faster.

Avoid code duplication
My number one rule of all time is never ever repeat code. Even one or two similar lines could cause problems. Never copy and paste. A set of code with absolutely no redundancy is called "Fully Factored". Fully Factored code is MUCH easier to deal with than code created with too much Copy and Paste.

This is also referred to as the "DRY" principle: Do not Repeat Yourself.

I'd go so far as to say that you could differentiate languages by how difficult it was to avoid repeated code.

Identify Repeated Code
Copy and Pasters will generally copy a block and paste it multiple times, Then go through and change a few constants to suit the needs of the new block of code. These are pretty easy to see, simply scan your code for repeated patterns of line lengths.

Extract unique data from repeated blocks of code
Often the solution is to extract the constants into an array, remove all but one copy of the offending code, then iterate over the remaining copy of the code.

This often leads to other opportunities for code reduction. For instance, when the changing "constant" in the code is a function/method call (a different method name at the same spot in each set of duplicated code), you may find a lot of redundancy in the called methods. This will also often lead to the creation of new objects and reusable structures of data that you didn't have before. A good optimization will often kick off a whole series of refactoring and you may find yourself removing so much code that it's embarrassing.

Certain language structures seem to just draw programmers to code duplications. Setting up GUI components, for instance, can be extremely repetitive. This is a good place to look for code reduction opportunities. Java requires that each MenuItem object has a class defined. Often you will see this implemented as a screen of code doing nothing but creating MenuItem objects. It can be just as easily done (MUCH easier actually) by defining a set of data and writing a small routine to create all the MenuItem classes. At this point you find that suddenly an action like adding buttons for each menu item that may have been terrifying before the refactor is now trivial.

Fully factoring code often requires setting up some data and iterating over it. In Java, setting up an array of data in code is quite concise. Later, array data could be very easily externalized, much easier than the original C&P code. To set up an array in Java, get used to this simple syntax (other languages should have similar constructs):

Strings are common, but you could also use int or long arrays--the syntax is identical. I often use Object arrays to pair an integer with a string: new Object[] {"One", 1, "Two", 2}... (This will work in Java 5, before Java 5 you might be better off with two arrays. The trick of these arrays is to keep the syntax simple and brief.

Often control signals are needed in your data as well. Don't be afraid to include required signals in your code. For instance, if you were automatically generating a set of menus, you need to identify which menus are top level and which are sub-items. A list like this should be all the data you need:

"^", "File", "Load", "Save", "^", "Edit", "Copy", "Paste"

This data can be fed into a simple loop (a few lines at most) to create your entire menu structure.

The Next Step, create a new class!
These data structures created from refactoring will generally end up with pairs of data, or triplets--or worse. Any time you have pairs or sets of data that want to be grouped together you should probably be defining a custom object to hold them. I know that sounds extreme, but try it. You will suddenly find that you needed that object all along. You should quickly find yourself moving code that used to be static utility methods (bad code smell) into your new class and it will have that perfect-fit good code smell.

You can create a string or object array and iterate over it to create your custom objects, but a better way is to actually create your objects in the array:

Here's a somewhat tricky one that I have used in the past:

MyClass[] primaryData=new MyClass[] { new MyClass("File", top), new MyClass("Save", "Save the file", "saveFunc"), new MyClass("Load", "Load the file", "loadFunc"), new MyClass("Edit", top), new MyClass("Copy", "Copy the selection", "copyFunc", "isTextSelectedFunc"), };

This uses a few tricks. First of all, there are multiple constructors. The top is (string, int) so that differentiates it and the system knows to create a new top-level menu item from this. All the following (without the int "top") added after it will become members of that menu. The rest of the constructors take strings--one string constructor takes 3 strings, the other takes 4.

The first string is obviously a menu name. The second is a tooltip, the third is the name of the function (in the originating object) to call (This is done through reflection). The fourth, if it exists is assumed to be a boolean method name that returns a T/F and can disable that menu item depending on the return value.

This code isn't exact, it was just an example. To really implement it, MyClass needs access to a few other things (like the calling object), but it gives you an idea.

Using this structure to implement a typical menu with 20 or 30 entries could replace many screens of C&P code. Also, you don't have to deal with the ugly "Inner class" syntax. You do have to deal with the ugly reflection syntax, but that's buried in the MyClass object and only needs to be dealt with once (ever).

You might also note that all your strings are in one place now. This means it would be extremely easy to replace those few lines of code with a data-driven routine. That might be a next step, it might not. I don't recommend trying to jump straight to data-driven.

Note on code sample
I coded it that way to make a point about storing classes in an array. If you were to really do it, I'd suggest creating one instance of MyClassHolder and passing in the calling class so MyClassHolder can make the reflective calls to it--then instead of "new" for each subsequent MyClass line, call a method in MyClassHolder that news MyClass for you and stores the instances inside itself. Leave a message in discussion tab if you'd like to see this really implemented. Also I could have distinguished "top" level items by the fact that they have a single parameter but I was trying to show a method that you can use if you can't differentiate each method by their parameters alone.

Warning: Don't key off visible strings
Notice that there is some redundancy in the data in the above example.

new MyClass("Save", "Save the file", "saveFunc"),

saveFunc could be calculated from Save. for instance you could just say the save function has to be named "doXFunc. so creating a "Save" option would automatically call doSaveFunc.

This usually works at first and seems like a nice trick, but in my experience--I've always regretted tying my internal name to externally displayed text, or using externally displayed text as any sort of a "Key". Eventually someone will want to implement it in a different language or something. I'm all for brevity but in this case it's just not worth it.

Warning: Be Very Careful with your data
Whenever you switch to data driven code most of your life will become much easier, however certain types of debugging become a lot harder--remember it is your job now to check the data.

 * Clearly define the data so it can be changed.
 * Be extremely picky about the data, allowing only the structure and values you have defined
 * Check references within your data (if they exist).
 * Fail LOUDLY with a clear explanation of the problem.
 * When users ignore your explanation and say it's your code's fault without reading it, ask them what you could have done to make them read the message and fix their problem. Put everything you learn back into the code.
 * If the data is complex enough, consider implementing an editor.
 * Data can easily be stored in .properties files (annoying), XML or a Database--or any number of other ways, pick the one easiest for you--.properties files make relating associated data difficult, and Databases almost require an editor. XML is a good balance.

Be SURE to validate the demarcation between your data and the rest of the program. For instance, in the example above check each reflective string AT LOAD TIME. In fact, you should instantiate the Method object as you load the MyClass object and store the method object instead of reflecting each time anyway.

Keep in mind that a spelling error in your data can be trivial to detect if you write error checking code like this--virtually impossible otherwise.

Anonymous Inner Classes
Anonymous inner classes is another case that leads to C&P. For instance, whenever the value of a control is changed you may want to validate the form. Worst case: the entire validation method is C&P into each anon listener. Better case: Each listener calls a "Validation method".

Fix
All the anon listeners should be similar, if not identical.

Create an inner class (not anonymous) that extends your basic listener type (ActionListener, ...) Put the code from one of the anonymousinner classes in here. If all the inner classes were identical, you can make the class stateless (no internal variables).

If it's stateless, create a single instance and pass it into each place where the listener was created. You're done. You probably cut your file size by 1/3 to 2/3 depending on what else was going on. You probably also eliminated 2 or 3 typo-related bugs in the process.

If your anonymous inner classes were slightly different, you should be able to pass in a variable when you instantiate the inner class, and use that variable to control the differences. If you do this, you will have to create more than one instance of the class--one for each different type. I still recommend you make them immutable, otherwise you need to create an instance for each listener.

If they have some differences, you could create a base class listener and inherit to a few sub-classes--just as you would with any OO code. There is no reason to treat listeners differently just because you almost always see them as anons.

Finally, if they are very different, just create 2 or 3 different classes. You can leave any anonymous inner classes that are unique alone, but where the code in the listeners are identical or very similar, please try to combine them.

Function/method size
Try to keep functions/methods down to one screen. You'll fail a lot, but it's a good goal. You should start to feel really uncomfortable if you see a function creep up to 2 or 3 screens in length.

It's much easier to deal with a bunch of small functions than one big one.

Please don't do this by daisy-chaining though. To simply break a function in the middle just because it's getting too long is even worse.

As I said in the Comments section, good OO code looks like it's not doing anything--anywhere. I don't think I've ever seen a method in the Java classes longer than a screen (after removing comments), and a huge majority are 1-3 lines of code. I just scanned Hashtable. Not a single method exceeds a screen (say, 25 lines or so) and most are smaller--all are very small and focused on solving 1 problem.

Each method or function should do only one thing. This functional breakdown makes it easier to manage and can provider a level of abstraction that was probably unrealized during the planning process. Generally, if the code runs longer than 40 lines, you may be doing to much in one step. If you feel that the functionality should not be exposed to other developers, set the method to private.

Public Variables/Variable Scope
I have come to the conclusion that every variable should be private. Always. Sometimes I'll implement a trivial class--rectangle or even "Pair" and make the variables public so I don't have to write setters/getters. I've always regretted it eventually.

Even protected variables are annoying. Write a simple protected getter if you must (Getters and setters can be a bad idea too--google "Getters and Setters are evil" for a great article.)

Passing a mutable object around can be as bad as a global. Be very careful with mutable objects (most Java objects like String are immutable and therefore much safer)


text:
XForms/Horizontal File Tab Menu

Sample Horizontal Tab Menu
This is an example of a horizontal tab menu using CSS and the XForms switch and case statements. Both the tab inside the horizontal tab menu and the div inside the case have the same background color giving the appearance of the selected tab popping to the front of the others.

Screen Image
You should see a menu that looks similar to this when running under the FireFox browser:

Note that the tab that is selected has the same color of the content.

Link to XForms Application
Horizontal Tabbox

Testing
Note that the text under the selected tab changes when you click on the tab.

Discussion
One of the best ways to reduce your JavaScript is to start converting your menus to use XForms.

This example can be modified to also conditionally display tabs based on state variables in the model.

This example should be made consistent with the XUL  element. If XForms used all the XUL elements this entire example would be much easier to be a standard.

Hopefully XUL and XForms will be consistent in the future.

Using the target pseudo element
Here is an example that uses the CSS-3 target pseudo element:

W3C Target Example

We could also modify the example to work with XForms.

Using the Non-Standard Attribute Value Templates (AVT)
XForms version 1.0 does not include the ability to put conditional statements within attribute values. Attribute values are text right of the equal sign usually enclosed in double quotes.

Some vendors that have implemented a feature called "AVT" that can be used to conditionally change the values of class attributes. For example:

This effectively will change the style for each tab to use the selected or not-selected style.

Future versions of XForms standards may include AVT functions.

title: XForms/Horizontal File Tab Menu


text: Template:South Slavonic languages

title: Template:South Slavonic languages


text:
Ukrainian Dancing/Hutzulshchyna/Basic and Common Steps

To add to this page, go to Template:Steps. Click on edit this page, and then highlight and copy the entire template. Return to this page and click on edit this page. Go to the end of the page and paste the template. Update the template with your description of the steps.

Description

 * 1) Before the first beat, hop on the left foot and raise the right foot so that it is next to the left knee, toes pointed downward.
 * 2) On one, hop on the left foot and lower the right foot so that the ball of the right foot is touching the ground, next to the left foot.
 * 3) On and, hop on the left foot and raise the right foot so that it is next to the left knee, toes pointed downward.

Repeat on the next beat.

The step may also be performed to the left side, reversing the working and supporting legs.

The step may be performed stationary, while travelling sideways, or turning. When travelling, the dancer moves in the direction of the working foot, and away from the supporting leg. When turning, the dancer turns in the direction of the working leg, pivoting on the supporting leg (i.e. when turning to the right, the right foot is raised.

Description

 * 1) On one, hop forward onto the ball of the right foot.
 * 2) On two, hop onto the left foot, bringing the left foot next to the right foot.
 * 3) On three, hop forward onto the right foot, bending the left knee back and bringing the left foot up at least parallel to the floor.  The left foot should be pointed.  Knees are kept together, and the left leg is raised behind the dancer.

Repeat to the other side, starting by hopping onto the left foot.


text:
User talk:Zagster

Recently Added

Battle Network 6

 * GigaCannon1 - 400 Damage Cannon attack
 * Cannon A, Cannon B, Cannon C
 * GigaCannon2 - 500 Damage Cannon attack
 * HiCannon L, Hi-Cannon M, Hi-Cannon N
 * GigaCannon3 - 600 Damage Cannon attack
 * MegaCannon R, MegaCannon S, MegaCannon T

title: User talk:Zagster


text:
XForms/Select1

Motivation
You want an input control that allows a user to select one and only one item from a list of possible items. You have enough room on the form to display all the possible values. You would also like what the user sees and what is placed in the instance to be different.

Method
Any time you would like the user to make a single selection from a list of possible options you can use the XForms   control. There are two variations of this, one to display all the values (also known as a radio-button) and one that presents a drop-down list and thus takes up less screen area.

Each item on the list of possible choices must have an   and within that it must have a   and an optional  . The value is the string that will be inserted into the data element that is referenced using the   property. The   property points to a data element in your model.

Link to Working XForms Example
Select1 Radio Buttons

Note that the lower-case value will be displayed under the select1 control to show you how the select1 control is changing the model. Only the labels are shown to the user.

Example Program
In the example below, the instance variable MyCode inside MyModel will be set to the value selected by the radio buttons control.

  XForms Radio Button Usng Select1 appearance="full"   Red red   Orange orange   <xf:label>Yellow</xf:label> <xf:value>yellow</xf:value> </xf:item> <xf:item> <xf:label>Green</xf:label> <xf:value>green</xf:value> </xf:item> <xf:item> <xf:label>Blue</xf:label> <xf:value>blue</xf:value> </xf:item> </xf:select1> Output: <xf:output ref="ColorCode"/>

Testing
You should see all the possible values when you use a full appearance. Each time you click on one of the radio buttons, the value of MyCode in the model will be updated and the output should automatically be updated. Note that the value is displayed (in lowercase), not the label.

Changing the Orientation to Horizontal
You can change the radio button to use a horizontal layout by applying float:left style to all the item elements.

In your CSS do the following:

In your body wrap all of the xf:item elements in a div with a class="horiz"

Discussion
You can always change a radio button to a drop down list by just removing the   attribute from the select1 element.

You can also use an XPath expression to display labels and values from the model using the xf:itemset element.

See the other examples for examples of this.

Acknowledgments
The question about horizontal layout was posted on the mozilla.dev.tech.xforms mailing list in April of 2008 and the solution was provided by Aaron from IBM.

title: XForms/Select1


text:
Template:CSS:property

Property

title: Template:CSS:property


text:
Template:CSS:value

Value

title: Template:CSS:value


text:
Using Ratpoison/Example Config

#Copyright (C) 2006 by maru dubshinki #Author: maru dubshinki  #License: BSD license, minus advertising clause. #Where: http://en.wikipedia.org/wiki/User:Marudubshinki/.ratpoisonrc #When: Time-stamp: "2006-09-06 18:22:39 maru" #Keywords: local,customization,ratpoison #Commentary #This is my own all-singing all-dancing personal ratpoisonrc. #It depends on two scripts, rpws, and expose (which can either be gotten    #at Reactorcore or at the ratpoison wiki) and a number of other programs, chief #among which are xclip, surfraw, and firefox. #Anyway, there are three main sections, so to speak. #The first tweaks some ratpoison settings directly. The main feature of    #note is the changing of the escape sequence from two keys, C-t, to a single #key (called by ratpoison "less"), and the mirroring of less with another key, #so there are actually two equivalent escape keys. #The second section runs a number of programs like unclutter. This section generally #modifies X, modifies the keybindings (i.e making caps lock a control), and runs some #useful programs if possible. #The third section handles application key bindings. My general philosophy here has #been to make the lower-case key invoke the "heavy" or feature-rich version of the #idealized type of application, and the uppercase one runs a different, smaller and #lighter-weight application which does much the same thing. For example, d runs #Firefox, and D runs terminal elinks. e runs Emacs, and E runs nano in a terminal. #And so on. ##change directory to $HOME chdir ##What's the shell? alias term exec aterm ##Banish the mouse with each screenchange #addhook switchwin banish ##Setting the prefix keys ###Set the ctrl-t key to something easier escape less ###Set the ctrl-t key to something easier definekey top Insert readkey root definekey root Insert link less ##Set the mouse warping option. warp on    ##Hush up, ratpoison. I know what the prefix key is. startup_message off ##There are three different ways ratpoison can "name" frames. ##By title, name, or class. Title gets you gunk like "emacs@localhost.localdomain"; ##but name and class give you the sensible "emacs" or "Emacs". set winname class ##Graphics tweaks ###Not quite sure what these do, copied from Reactor Core. ###Supposedly make borders take up less space. defborder 0 defpadding 0 0 0 0 defbarpadding 0 0 #This was suggested on the ratpoison wiki as a way to    #make messages clearer. Doesn't work right now. Maybe I have the wrong #font name? #deffont -etl-*-*-r-*-*-*-400-*-*-*-*-*-* ##What programs do we run on startup? ###Do some key re-mapping exec xmodmap -quiet ~/.Xmodmap ###Apparently modifies some low-level GUI bits of X.    exec xrdb -load ~/.Xresources ###Change the background and pointer in X    #exec xsetroot -solid black -cursor_name left_ptr exec xsetroot -cursor_name left_ptr ###I like astronomical images. Let us make use of xplanet. #exec xplanet -body earth -fork -random -light_time -transparency -wait 60 ####This is an alternative- setting electricsheep as the background. #exec electricsheep --root 1 --nick maru --zoom 1 --mplayer 1 --history 50 & ###Set a background, randomly picking from a certain directory. exec cd ~/pics && xsetbg -border black -fork -type jpeg -fit -onroot -fullscreen `w=(*.jpg); n=${#w[@]}; echo "${w[RANDOM%n]}"` && cd ~/ #exec xsetbg -border black -fork -type jpeg -fit -onroot -fullscreen `w=(*.jpg); n=${#w[@]}; echo "~/pics/${w[RANDOM%n]}"` ###Run unclutter so the mouse hangs around no longer than needed. exec unclutter -idle 1 -jitter 2 -root ###I use xscreensaver as a screensaver. The first line makes sure any running xscreensaver is killed. ###The second starts and backgrounds xscreensaver exec xscreensaver-command -exit exec xscreensaver & ###This should set up rpws and groups ###http://ratpoison.elektrubadur.se/rpws exec rpws -i exec rpws -b ###This should be pretty obvious. Why not use function keys? bind F1 exec ~/bin/rpws 1 bind F2 exec ~/bin/rpws 2 bind F3 exec ~/bin/rpws 3 bind F4 exec ~/bin/rpws 4 bind F5 exec ~/bin/rpws 5 bind F6 exec ~/bin/rpws 6 bind F7 exec ~/bin/rpws 7 bind F8 exec ~/bin/rpws 8 bind F9 exec ~/bin/rpws 9 bind F10 exec ~/bin/rpws 10 bind F11 exec ~/bin/rpws 11 bind F12 exec ~/bin/rpws 12 ###xbindkeys can alias for some neat things. #This is last- low priority. Commented out, currently does nothing, #exec xbindkeys ##aliasing keys within ratpoison ###make semicolon invoke ratpoison command, and colon shell command. bind semicolon colon bind colon exec ###Show-the-root-window script alias showroot exec ratpoison -c fdump; ratpoison -c 'select -' -c only alias unshowroot exec ratpoison -c "frestore `cat $HOME/.rpfdump`" #bind B showroot ###Change the date from 24-hour to 12-hour bind a time ###(Getting a root terminal. There is no binding for "c", since that    ###is a default binding, to a terminal.) ###I've since changed this since I don't use it very often. #bind C exec ssh -X root@127.0.0.1 aterm bind C colon exec aterm -e ###Shortcut for emacs. Emacsclient is called, but it expects ###a filename. This can be circumvented by instructing it to    ###instead evaluate a Emacslisp expression- the current one ###says "open up a new frame on the current display device". ###It has to be quoted or else sh will try to open up the lisp ###expression in a sub-shell as a shell command. ###Neatly, if an emacs isn't already running, then emacsclient runs ###$EDITOR, which points back to regular emacs! bind M-e exec emacsclient --eval '(make-frame-command)' ###Shortcut for nano bind M-E exec aterm -e nano ###Shortcut for firefox bind d exec mozilla-firefox #bind d exec mozilla-firefox & ratpoison -c "title firefox" ###A new hack using xclip (which prints out the current text selection) to    ###open up a new tab in a running firefox with the address as the current selection. ###The idea is, you highlight an URL and then instead of manually inputting it, ###simply whack R-b ('b' standing for "browse"). #bind b exec mozilla-firefox -new-tab `xclip -o` bind B exec mozilla-firefox -new-tab `$RATPOISON -c getsel` bind b colon exec mozilla-firefox ###Shortcut for elinks bind D elinks http://www.google.com/ #bind B elinks http://www.google.com/ ###Shortcut for dillo- currently I use elinks instead. dillo's    ###keyboard commands are too awkward as of yet. #bind D exec dillo ###Shortcut for gqview bind g exec gqview +t ###Binding for xpdf bind x exec xpdf ###Runs a perl script which emulates the Mac's expose feature. ###http://ratpoison.elektrubadur.se/expose.pl    bind w exec ~/bin/expose.pl     ###Runs a shell script which creates an alt-tab menu analog ###http://reactor-core.org/ratpoison-config.html bind W exec ~/bin/windows ###Make prtscreen work, as long as in ratpoison mode. "import" is an Imagemagick command. bind Print exec import -window root png:$HOME/xwd-$(date +%s)$$.png ###Crikey, I'm gonna need a separate section just for surfraw shortcuts. ###Anyway, the model for these (thanks to aon) is "bind r colon exec surfraw wikipedia "- note ###the space. If the space isn't there, then the user will need to manually add a space, which is not good ###In the shell, one can omit the surfraw command, but not in ratpoison, as ratpoison's PATH currently does ###not include the directory with the elvi in it. ###List of useful surfraw elvi follows: ###amazon bbcnews cia cite cnn debbugs debcontents deblists deblogs debpackages debpts deja dmoz ebay etym freshmeat google imdb rfc rhyme slashdot sourceforgen translate ###Surfraw aliases. alias cnn exec surfraw cnn alias debbugs exec surfraw debbugs alias debbug debbugs alias debpackages exec surfraw debpackages alias google exec surfraw google alias gutenberg exec surfraw gutenberg alias surfraw exec surfraw alias wayback exec surfraw wayback alias wikipedia exec surfraw wikipedia alias wookieepedia exec wookieepedia ###Surfraw keybindings bind t colon wikipedia #bind t exec wikipedia `xclip -o` #See previous comment for R-b bind T exec wikipedia `$RATPOISON -c getsel` bind E google `$RATPOISON -c getsel` bind e colon google #bind T colon google bind Y colon wayback bind y colon wookieepedia bind u colon debbugs bind U colon debpackages ##Aliasing long commands within ratpoison ###Leaving open the option to use conkeror, a skin over firefox. ###Wish I could get sane tabbed browsing in it...    alias conkeror exec mozilla-firefox -chrome chrome://conkeror/content alias elinks exec aterm -e elinks
 * 1) .ratpoisonrc --- my own ratpoison customizations

title: Using Ratpoison/Example Config


text: Template:HTML:attribute

title: Template:HTML:attribute


text:
English in Use/Vocabulary

= Animals =

=House= =Automobiles=

= Human =

Food storage
=Fruits=

=Places=

=Consumable things=

title: English in Use/Vocabulary


text:
Biblical Studies/Christianity/Roman Catholicism/Sacraments

The seven Sacraments are: Baptism, Penance/Reconciliation, Holy Eucharist, Confirmation, Matrimony, Holy Orders, and Extreme Unction/Anointing of the Sick.

Baptism
Baptism is given "in the Name of the Father, and of the Son, and of the Holy Spirit." Baptism only given once and is permanent; even if a person later "leaves" the Catholic Church, he/she is still a member, and if the person repents and returns to the Church, no rebaptizing is necessary. If there is uncertainty of a person's baptism of lack thereof, "conditional baptism" is administered ("If you have not already been baptised, I baptise you in the Name...")

All properly baptised persons, even those not in complete communion with the Roman Pontiff, are members of the Church of Christ and may rightfully be called "Christians" and "brethren in Christ." Baptism permanently makes one a Christian, cannot be undone, and never needs to be given a second time. Although a person may enter into heresy or schism, or even completely reject Christianity and apostasize, the person will never be able to cease being a Christian. Although the Catholic Church may use penalties and censures to attempt to reform a person or minimize the harm a person can do, it does not have the power to revoke Baptism or expel a member from the Church.

Penance/Reconciliation
A penitent is absolved "in the Name of the Father, and of the Son, and of the Holy Spirit." It is required that all mortal sins be confessed, and the confession of venial sins is encouraged. Catholics are required to confess mortal sins at least once a year. There is no limit as to how many times this sacrament may be administered to a penitent.

Holy Eucharist
Bread and wine are transformed into the Body and Blood of Christ in the context of the Sacrifice of the Mass. Communion is usually received in the course of the Mass; however, Communion may also be received in a Communion Service (and even outside of a Communion Service in some cases?) Catholics are required to receive Communion at least once in the course of the Easter period. Catholics must be in the state of grace to receive Communion. Currently, a person may receive communion twice a day, but the second time must be in the course of a complete Mass attended by the recipient.

Confirmation
Confirmation is given once in a person's lifetime and is also permanent. If a person later "leaves" the Catholic Church, and later repents and returns to the Church, no reconfirmation is necessary.

Matrimony
The Sacrament of Matrimony, when properly administered without impediments and consummated, is permanent until the death of one of the two spouses. If a marriage is not properly administered or there are impediments, an annulment is granted, which is a determination that the marriage was never valid in the first place. If a marriage is not consummated, it is possible to get what is called an ecclesiastical divorce. Marriage is only valid between one man and one woman.

Holy Orders
Holy Orders is the ordination of candidates to the priesthood. This sacrament is only given once and is permanent; if a priest later "leaves" the Catholic Church, he/she is still a priest, and if the priest repents and returns to the Church, no reordination is necessary. Even if a priest is laicised, he still may give the Last Rites to a person in danger of death. In general, those who are ordained priests are required to be unmarried. An exception is made for certain Protestant ministers who convert to Catholicism.

Extreme Unction/Anointing of the Sick
This Sacrament is given in cases of sickness, imminent death, or old age. It is usually given only once per occasion, but in the case of an extended illness, it is often received more than once. When it is administered, it is often given with the Sacraments of Penance and the holy Eucharist; the reception of these sacraments is often collectively called the Last Rites.


text:
User:Ilog

my ideas blog

title: User:Ilog


text:
Irish

Fáilte!
Fáilte (Welcome) to Wikibooks Irish, an open source primer and resource for the Irish language.

The Irish Language
Irish (Gaeilge), (not to be confused with Scottish Gaelic, which is also sometimes called Gaelic, click the link for that wikibook.) is the traditional language of Ireland, and is currently spoken as a daily language by around 70,000 people. It is also taught in most Irish schools. It is in the Goidelic branch of the Celtic language family along with Scots Gaelic and Manx. Other Celtic languages are Welsh, Breton and Cornish.

Irish was once the main spoken language of Ireland and an important religious language. However, since about the 19th century, the language has declined rapidly and despite multiple efforts at revival by subsequent Irish governments, is now a minority language and considered endangered.

About This Book
This book contains lessons in the Irish language, as well as grammatical and historical information. The book is organized into three units.

 Unit 1 is an introductory unit for absolute beginners. It focuses on pronunciation and spelling, while introducing some basic points of grammar. Most language concepts will be introduced and explained entirely in English, except for concepts such as séimhiú (lenition) and úrú (eclipsis), where the English terms would be equally unfamiliar.

 Unit 2 will provide a comprehensive overview of Irish language and grammar, including review and further coverage of the concepts introduced in Unit One. It will include a more comprehensive general vocabulary. Irish terms will be used for language concepts, with English reminders where appropriate. Students with some experience in Irish may want to start with Unit Two.

 Unit 3 will provide more in-depth coverage of language used in specific subject matters. Grammar will be reviewed briefly, but the focus will be on specialized vocabulary and terminology. Language concepts and some basic prompts will be given in Irish only. Unlike the lessons in Units One and Two, which are designed to be studied in a specific order, lessons in Unit Three will be grouped by subject matter and can be studied in any order, using the foundation built in Units One and Two. Students with confidence in their Irish may use Unit Three to learn the words they need to discuss specific subject matter.

This book is a work in progress. If you are interested in contributing, please visit this page's discussion page, or the lesson planning page, and join in!

Iirin kieli Ирландский язык

title: Irish


text:
Practical Electronics/Signals/Basics

An electrical signal can refer to any quantity that veries with time. Usually, this quantity is voltage.

title: Practical Electronics/Signals/Basics


text:
User:Username222

Hi, I'm Username222 or GREDnFORGE222. I help on linking the pages and adding minor details. I also format new pages.

I try to contribute more on Muggles' Guide now, but not a big contributer yet. GREDnFORGE222 19:26, 1 January 2007 (UTC)

title: User:Username222


text:
World Stamp Catalogue/Liechtenstein

=Stamps of Liechtenstein=

Until January 31st 1921 Austrian stamps could be used in Liechtenstein.

 * Postage stamps and postal history of Liechtenstein (English)
 * История почты и почтовых марок Лихтенштейна (Russian)

1917
Liechtenstein |Liechtenstein

title: World Stamp Catalogue/Liechtenstein


text:
User:Panu Höglund

Renowned web expert of Irish language. My one and only project: Irish Language Lessons.

title: User:Panu Höglund


text:
Talk:World Stamp Catalogue

Is anyone still working on this project? Kempm 21:08, 10 September 2006 (UTC)

I'd like to propose a different way of adding stamps to the catalogue. The current way, adding stamps into the catalogue is using the tabular template. However there are a few things missing.

What we need, in my view, is:
 * Picture of the stamp
 * Date the stamp was first released
 * Date until this stamp could be used
 * Common description of the stamp
 * Designer of the stamp
 * Company that printed the stamp
 * A big room for stamp values (First Day Envelopes, Misprints, Mints, Used, etc)
 * Number of stamps printed
 * Paper used
 * All other things related to the stamps, like background stories, etc)

Further, to avoid long pages, that take up much server load to show all these stamps, I would like to propose deep linking stamps. Common way to do it: World_Stamp_Catalogue/Region/Country/Year.

In my view Catalogue Number is no longer important because there are several companies out there, that all use their own numbering. Also these numbers can vary every year. So my proposal for this would be to leave out the Catalogue Number field from now on. Kempm 11:07, 16 September 2006 (UTC)

 * Basic example of the proposal can be found at: World_Stamp_Catalogue/European_countries/Stamps_of_Faroe_Islands/1975 I think what is needed is a nice way to arrange the text. If some standard can be found for this, it would be nice. My webdevelopment skills are not very well developed, though :/ -Kempm 12:44, 16 September 2006 (UTC)

I only just became aware that this project was started. I find the tabular format interesting, and a possible basis for future development. The additional material that you suggest is mostly very interesting, but we have to accept that much of it cannot be added without extensive research. Adding what is possible should not be restricted by what we cannot find easily.

Values are a subjective question of supply and demand. Even the Scott Catalogue recognizes the valuation problems when it puts a value in italics. There is more to this than the number printed and the age of the stamp. For example, a good quality German stamp will do much better in a European auction than in a North American auction. A key topical stamp will have a higher value because it will be demanded by both the collectors of the topic and of its country.

I disagree about catalogue numbers. The catalogue numbers developed by the existing catalogues, especially the four major ones, have their idiosyncracies. There are also unresolved copyright problems over the use of these proprietary numbers. Scott has actively protected its numbers, and although Krause-Whitman's dispute with them did much to put Scott's copyrights in doubt the out-of-court settlement meant that the question was not publicly answered. Having a numbering system that is free of copyright restrictions and that can be used uniformly around the world has a certain appeal. Eclecticology 02:30, 14 November 2006 (UTC)

 * Nice to see someone working on this project. Welcome Eclecticology.
 * I understand that values are a difficult topic, but I was more thinking about a system like this: January 16th, 2004, bought stamp 234 mint for 100 euro. Someone else writes: June 23rd, 2005, bought stamp 234 mint for 150 dollars. Or Michel catalogue 1999 values stamp 234 at 100 Deutsche Mark. Something like this should give a pretty good idea of a value of a certain stamp. (In my view catalogues are mainly used to catagorize one's own collection, and for stamp values, therefore stamp values are very important, and should not be omitted).
 * You clearly know more about the catalogue numbers than me. Any idea how Michel catalogue numbers relate to Scott's numbers. And if they differ what numbering do you suggest this project will follow? --Kempm 10:08, 20 November 2006 (UTC)

 * OK just noticed your work on Stamps numbering. Seems good, that concern of mine has been solved. Thanks --Kempm 10:23, 20 November 2006 (UTC)

 * Thanks for noticing. This seemed like a quiet corner to work, and there's no shortage of work.  With the numbering I chose to start with an issue from China because the complexities there would be more likely to force me to deal with the problems.  Already I have needed to make some adjustments to the scheme as information is processed.  I find working with images to be a tedious process; when I put them on line they never seem to look like the original stamp that I scanned.  In the short run I at least hope to upload enough to be able to illustrate significant differences between stamps.  When I bought my scanner several years ago it was with the intent of being able to resolve tiny details that differentiate between two stamps.  Scanning whole pages at such a resolution would give ridiculously huge files, but makes sense when zooming in.

 * Another thing that I hope to develop is a co-ordination between catalog numbers and the names for image files. The question of copyright is somewhat different in this subject area.  Fair use claims are essential, and there does not appear to be any attempt by any modern government to stop the use of stamp images in dead-tree catalogues.  Wikipedia currently allows fair use images for stamps as long as they are used to illustrate an existing article.  This would not be consistent with the strict prohibition against fair use in Commons.  For the forseeable future, however, I see most of my efforts directed toward stamp designs that were first issued more than 50 years ago, and which would at least fall within the Berne Convention view of public domain.  It's also a convenient way to add a little control to my personal time management.

 * Values are a tough area to research. Speaking for myself I tend to buy in bulk and am a poor record keeper.  It can sometimes be many years before I even discover that I have a relatively more valuable variety.  My collection accumulation is unmanageably large, and I also have a substantial collection of philatelic literature that I can use as references.

 * If others want to start uploading images that would be appreciated. If they want to work on the stamps of particular countries and years they only need to let me know and I can shift my priorities for number development. Eclecticology 22:37, 8 December 2006 (UTC)

US Stamp section
I just added the module World Stamp Catalogue/United States, which is a copy of what I had created as a Commons article (Stamps of the United States) based on the US stamp images there. I have not yet made an attempt to conform to the World Stamp Catalogue format or content. I mainly wanted to provide an indication of what US stamp images are available on Wikimedia Commons. Feel free to do any constructive reformatting that would help. Some scans from my personal collection are shown in commons:User:Nonenmac/postage stamps. — Nonenmac 03:06, 14 May 2007 (UTC)

Is this project still alive?
Recently, a website called Colnect started presenting a collector-generated stamps catalog that is open to the public. It appears that collectors there are more motivated to update the catalog because they can later use it to manage their own swaps with the aid of that catalog. Perhaps it's worth some while to look there and perhaps cooperate with it?

Image policy?
Whats our image policy? The Commons policy only? Fair-use also? Can we take fair-use images from language wikipedias?

AshLin (talk) 05:48, 3 April 2009 (UTC)

Reviving This Project 2016
Seems that this project has withered on the vine. I was thinking of doing something similar to this since I did not know this Wikibook existed, and was directed here by the people who run the main Wikipedia philately portal. I am very keen to see this wikibook take off, it looks like it has a good base foundation for structure, it just lacks content. If no one objects I will start working on some revisions to this to add content (I am a worldwide collector with an interest in specialized listings to boot). --DJCMH (discuss • contribs) 17:17, 29 April 2016 (UTC)

Additional Template Fields
I think the listing should have a few more fields for information. I would like to see included

Printing Method Printer Dimensions Separation of Designer/Engraver into 2 Separate Fields (these are usually 2 different people in French colonial stamp production, for example) A separate Watermark field separate from Type (??) --DJCMH (discuss • contribs) 18:34, 29 April 2016 (UTC)

Use of Catalogue Numbers
Due to the questions of copyright status, the use of published catalogue numbers from the established producers should probably not be used at present time. I will be removing such information from the postings I have made. Whether this makes continuation of the project in some form worth the effort is another question.--DJCMH (discuss • contribs) 09:33, 2 May 2016 (UTC)

title: Talk:World Stamp Catalogue


text:
Minix 3/Architecture and Design of MINIX 3

Kernel
The kernel is the central part in most computer operating systems which manages the system's resources and the communication between hardware and software components. As a basic component of an operating system, a kernel provides abstraction layers for hardware, especially for memory, processors and I/O that allows hardware and software to communicate. It also makes these facilities available to userland applications through inter-process communication mechanisms and system calls.

These tasks are done differently by different kernels, depending on their design and implementation. While monolithic kernels will try to achieve these goals by executing all the code in the same address space to increase the performance of the system, microkernels run most of their services in user space, aiming to improve maintainability and modularity of the codebase.

Overview
Most, but not all, OS rely on the kernel concept. The existence of a kernel as a single piece of software responsible for the communication between the hardware and the software results from complex compromises relating to questions of performance, memory efficiency, security and processor architectures.

In most cases, the boot loader starts the kernel as a process in supervisor mode, but after initialization, it does not remain as a process as we know it, but instead as a whole set of functions that can be invoked by userland applications to perform operations that require a higher privilege level, such as disk access. Kernel execution streams are a continuation of execution streams of userland processes that are paused when performing system calls and resumed when those return. The initial main kernel stream remains as the "idle process" and "collects" unused processor time.

Kernel development is considered one of the most complex and difficult tasks in programming. Its central position in an operating system implies the necessity for good performance, which defines the kernel as a critical piece of software and makes its correct design and implementation difficult. A kernel might even not be allowed to use the abstraction mechanisms it provides to other software. Many reasons prevent a kernel from using facilities it provides, such as: interrupt management, memory management and lack of reentrancy, thus making its development even more difficult for software engineers.

Different Kernel Design Approaches
Naturally, the above listed tasks and features can be provided in many ways that differ from each other in design and implementation. While monolithic kernels execute all of their code in the same address space (kernel space) to increase the performance of the system, microkernels try to run most of their services in user space, aiming to improve maintainability and modularity of the codebase. Most kernels do not fit exactly into one of these categories, but are rather found in between these two designs. These are called hybrid kernels. More exotic designs, such as nanokernels and exokernels, are mostly investigated by researchers and are not in widespread use.

Monolithic Kernels
In a monolithic kernel, all OS services run along with the main kernel thread, thus also residing in the same memory area. This approach provides rich and powerful hardware access. Monolithic systems are easier to design and implement than other solutions, and are extremely efficient if well-written. The main disadvantages of monolithic kernels are the dependencies between system components - a bug in a device driver might crash the entire system - and the fact that large kernels become very difficult to maintain.

Microkernels
The microkernel approach consists of defining a simple abstraction over the hardware, with a set of primitives or system calls to implement minimal OS services such as memory management, multitasking, and inter-process communication. Other services, including those normally provided by the kernel such as networking, are implemented in user-space programs, referred to as servers. Microkernels are easier to maintain than monolithic kernels, but the large number of system calls and context switches might slow down the system because they typically generate more overhead than plain function calls.

Microkernels generally underperform traditional designs, sometimes dramatically. This is due in large part to the overhead of moving in and out of the kernel, a context switch, to move data between the various applications and servers. It was originally believed that careful tuning could reduce this overhead dramatically, but by the mid-1990s most researchers had abandoned this approach. Recently, newer microkernels, optimized for performance, have addressed these problems.

Monolithic kernels vs Microkernels
As the computer kernel grows, a number of problems become evident. One of the most obvious is that the memory footprint increases. This is mitigated to some degree by perfecting the virtual memory system, but not all computer architectures have virtual memory support. To reduce the kernel's footprint, extensive editing has to be performed to carefully remove unneeded code, which can be very difficult with non-obvious interdependencies between parts of a kernel with millions of lines of code.

Due to the problems that monolithic kernels pose, they were considered obsolete by the early 1990s. As a result, the design of Linux using a monolithic kernel rather than a microkernel was the topic of a famous flame war between Linus Torvalds and Andrew Tanenbaum. There is merit on both sides of the argument presented in the Tanenbaum/Torvalds debate.

Most common kernels are monolithic; Windows NT, Linux and Apple's XNU kernel (the kernel behind Mac OS X) are a few examples, although there are many more. The majority of microkernels are either research kernels, or kernels for use in embedded systems for one task only.

Monolithic kernels tend to be easier to design correctly, and therefore may grow more quickly than a microkernel-based system. However, a bug in a monolithic system usually crashes the entire system; if the system is designed correctly, this doesn't happen in a microkernel with servers running apart from the main thread. Monolithic kernel proponents reason that incorrect code doesn't belong in a kernel, and that microkernels offer little advantage over correct code. There are success stories in both camps. Microkernels are often used in embedded robotic or medical computers where crash tolerance is important and most of the OS components reside in their own private, protected memory space. This is impossible with monolithic kernels, even with modern module-loading ones. However, the monolithic model tends to be more efficient through the use of shared kernel memory, rather than the slower message passing system of microkernel designs.


text: User:Kempm

title: User:Kempm


text:
User:Lor~enwikibooks/History of Japan

This Wikibook will chronicle the history of the Japanese islands, from the first arrival of humans some 100,000 years ago, to the modern industrial nation as it exists today.

 * Jomon Culture
 * Yayoi Culture
 * The Middle Ages
 * The Edo Period
 * The Meiji Era
 * Imperialistic Japan
 * World War Two
 * Modern Japan

title: User:Lor~enwikibooks/History of Japan


text:
XForms/Select1 drop list

Motivation
You want to allow the user to select a single value from a list.

Method
Here is an example of using the select1 to create a drop-down list. The user must pick one and only one from the selected list.

Note that each item has a label (for humans to read) and a value (usually placed within an XML document). Values are typically stored in a database and use to compare to items together. Since values are frequently passed as arguments in a URL in a REST interface the convention is to only use lowercase letters and dashs. Do not put spaces, slashes and other characters in values if you are using REST interfaces. This makes the URLs difficult to read.

Link to Working Application
Load XForms Application

Note that when the form is initially loaded, no day of the week is displayed in the input our output. After you press the drop-down list (the back triangle to the right of the input control) and select a day of the week the value will be filled in. A label (the name that starts with the uppercase) will be displayed in the select1 control. The actual version in the model will be the value which is the lower-case version. This is also the version that is displayed in the output.

Source Code
   Day of Week:  Monday monday   Tuesday tuesday </xf:item> <xf:item> <xf:label>Wednesday</xf:label> <xf:value>wednesday</xf:value> </xf:item> <xf:item> <xf:label>Thursday</xf:label> <xf:value>thursday</xf:value> </xf:item> <xf:item> <xf:label>Friday</xf:label> <xf:value>friday</xf:value> </xf:item> <xf:item> <xf:label>Saturday</xf:label> <xf:value>saturday</xf:value> </xf:item> <xf:item> <xf:label>Sunday</xf:label> <xf:value>sunday</xf:value> </xf:item> </xf:select1> Output: <xf:output ref="DayOfWeekCode"/>

Discussion
The list of values does not have to be in the body of the form. It can be in the model stored in an instance, it can be fetched on-demand from a web service. We will cover these in other examples.

title: XForms/Select1 drop list


text:
User:Jmoinian/Electro magnics

Teleportation

A man walks to a telephone booth and with a matter of second disappears; what happened? Where did he go? In movies such as Fly and Star Track you have seen people disappearing and reappearing in another place, Planet, or even another dimension. The act of moving one object or one person from one place to another place is called Teleportation. The name was given by science writers in order to attract reader’s attention to follow the rest of books’ contents.

In 1993 six group of international scientists including “IBM Fellow Charles H. Bennett” did an experiment by moving an object from one location to another and confirmed the “intuitions” of the science fictions’’ writers that teleportation is indeed possible.

This is how the teleportation works. An object or person is scanned in such a way to gather all the in formations from it. Then the information shall be send to the receiving station. There by using the data the replica shall be “constructed.” The teleportation machine works just like the fax machine does only in three dimensional. It shall produce the exact coy of the object or person to the last detail. However, in the process of scanning it shall destroy the original.

The idea of teleportation in the past was taken seriously because of “uncertainty principle of quantum mechanism.” According to this theory the more exact an object scans the more “disturbed” the original objects are until it reaches the point that is completely “disrupted. “So, there is not enough information to make the exact replica. This is a good argue to put an end to the teleportation theory. There is no way to make a perfect coy. But six scientists from IBM found out a way to put an end using the logic of “EPR (Einstein-Podolsky-Rosen) effect.”

This is how the effect works. You take an object and call it A which you would like to scan the information from. The place you send the information to shall be called B. The place that the replica shall be sending for treatment shall be called C.  C is never in direct contact with an A.  After transferring the informants to B and its treatments in C the A is not in the state of existing any longer; this process concluded that teleportation can be done, but there is no sign of” replication.” This was then but not through the use of “Quantum Teleportation” “The part of and object which is too delicate to be scanned out and delivered by conventional methods “can be delivered.

By using the theory of EPR in 1943 the department of Navy with the supervision of Dr. Albert Einstein conducted an unsuccessful experiment using USS Eldridge with a “full crew aboard without their knowledge the generators fired up. The switches were thrown “The sip dispread momentarily and repapered in a matter of second usefully; the effect on the experiment on the ship went well but on humans was a disaster. When the ship “rematerialized some of the crew were on fire. Some went insane. All of them were sick. Some had a heart attack. And some were part of the ships’ structure. This unfortunate attempt of teleportation was known as “Philadelphia Experiment. A full report of the experiment was given to the congress and the members were so horrified that they disbanded the project immediately.”

However, the researches such as “The Montauk Project, The Phoenix Project headed by Dr. Neumann was continued.” The teleportation project is still being continued by the government since it has great commercial and military use. Who knows may be one day very soon we say “Scotty beam me up.”

title: User:Jmoinian/Electro magnics


text:
Practical Electronics/Soldering

Soldering is the use of a conductive substance with a low melting point (solder) to electrically connect components together. It is frequently used to join wires to leads of components such as switches or to join components of all kinds to a printed circuit board. The primary tool used for applying solder is a soldering iron, a device whose metal tip heats to temperatures well above the melting point of solder. This is used to melt the solder and allow it to flow into a joint.

Soldering is an acquired skill, and it takes practice to become adept. There are many tips, tricks and guidelines on how to produce good soldered joints, and this module aims to present them to you.

The first and most important rule of soldering is to choose your tools with care. Both the solder and the iron must be chosen to suit the application. The first two sections below deal with the different kinds of solder and iron and which to choose for what.

About solder
Solder is a metallic compound that has a low melting point, usually around 200°C. The composition of solder varies depending on the type, but usually contains lead or tin or both. The most common types are given below. It is available in wire, stick or pellet form. Sticks and pellets are for solder-pots; for normal soldering, you will need solder wire.

Solder wire is a very flexible, silvery coloured wire that is usually supplied on reels that are sized by weight. Common weights are 250 g, 500 g, 1 kg or 2 kg. It generally costs around £6 or $12 for a 500 g reel. It is very soft, and is easily cut by wire cutters and smaller diameters can be snapped by hand (though this is not recommended, as you will see below).

Gauge
Solder wire is available in widths given in "standard wire gauge" (SWG). The larger the SWG number, the thinner the wire. Common gauges are 18 and 22, although others are available.

18 gauge solder is suitable for soldering large components and thick wire, as a large quantity of solder can be delivered quickly. However, for smaller, more detailed work, 18 gauge is too thick. Soldering the pins of standard dual in-line packages (DIPs) is about as fine as 18 gauge solder can usefully go.

22 gauge solder is thinner than 18 gauge, and should be used for most electronics work, as it allows much greater control over the quantity of solder delivered, and the chances of accidentally bridging a gap due to over-application or the wire's width are greatly reduced.

Finer gauges such as 26 are available for very fine work with SMT (surface-mount) components.

60/40

60/40 solder is made of 60% tin and 40% lead. It has a melting point of around 190°C, depending on the exact composition. Iron tip temperatures of at least 300°C are recommended. It is also very soft, meaning that cracks do not form so readily if the joint moves during cooling.

63/37
63/37 solder is made of 63% tin and 37% lead. It has a melting point of 183°C, slightly lower than the more common 60/40 blend. The primary advantage of this solder is not the lower melting point, but its eutectic property. Non-eutectic solders, like the 60/40 solder, have a semi-solid state between solid and liquid. If a joint is moved during this stage, it can result in what is called a cold solder joint. Eutectic solders, like the 63/37, do not have this semi-solid state and are thus considered easier to work with as it produces fewer bad joints. However, these solders typically cost more than their non-eutectic counterparts.

50/50
This is made of a half and half mix of tin and lead. Never use 50/50 solder for electronics — it is meant for plumbing. (There are brands[Worthington 50/50 leaded #331887], which is used for electronics and specifically not intended for plumbing). Otherwise, you may end up with failed joints, as the 50/50 solder does not have the same properties as 60/40, having a higher melting point and lower ductility. Also, it is very unlikely to have flux included in it like rosin core solders.

Lead-free solder
Solder containing lead is slowly being phased out under new EU directives (especially the RoHS and WEEE directives) and being replaced with solders consisting of tin-antimony alloys. It will likely be many years before lead solder is supplanted for good, but even now many shops do not sell lead solder any more. Lead-free solder has a higher melting point than lead solder and uses more aggressive fluxes. This means that the soldering iron will have to be made for lead-free solder in order to supply the right temperature — it melts at around 230°C — and the iron bits need a different coating to withstand the flux. Using a soldering iron meant for lead solders may result in dry joints and shortened bit life.

Lead-free solder is generally about 20%-50% more expensive than lead solder.

There are many different alloys and their properties can be found in this Wikipedia article.

Flux and rosin core solder

Flux is a compound that is used to improve the quality of the soldered joint. It does this in three ways:
 * It chemically removes oxidation from the surfaces being soldered.
 * It prevents air from oxidising the surfaces once they have been cleaned.
 * It increases the "wetting" of the surfaces when the solder is applied.

Wetting is the degree to which the solder flows across the surfaces being joined. Without flux, a dry joint may be formed, making a poor connection. See below for a description of dry joints.

Rosin core solder has channels inside filled with rosin flux. Because flux melts before the solder, the embedded flux automatically cleans the joint before the solder flows into it. Rosin core solder should always be used for electronics. Both lead and lead-free solder can be rosin core. Never use acid core solder for electronics — it is intended for plumbing and sheet metal work only, and the acid residue will corrode and ruin electrical joints. Acid flux remains chemically active at room temperature, while rosin flux becomes inert and harmless once the joint cools.

After soldering, a layer of flux may be seen around the joint. This is usually a burnt-looking brown layer (usually found when the joint has been overheated), or a shiny clear layer. This is not usually a problem, but you may want to remove it with a cotton bud soaked in methylated spirits or alcohol to produce a more professional appearance.

Flux is also available in "pen" applicators. This allows it to be applied, before soldering with rosin core solder, to surfaces that need to be very well fluxed such as SMT pads and unfluxed solder braid in order to be reliable.

About soldering irons
Soldering irons come in all shapes, sizes and power ratings. Most irons are made of a heating element attached to a handle, with interchangeable tips used to work on the joint.

Power rating and temperature control
The power rating governs how hot the iron gets and how quickly it heats up. A high power rating means that if a joint with a large thermal mass is being soldered, the bit will not cool down much. However, a high power rating used for fine work may overheat the joint, damaging the component or circuit board.

Generally, a rating of around 18 W is good for fine work, while a 25 W to 50 W rating is good for heavier electrical soldering, such as on mains lighting.

Inexpensive soldering irons have a fixed power consumption — they rely on the dissipation of heat into the surroundings to achieve thermal equilibrium at the desired temperature. These are sufficient for most hobby electronics work. A simple iron like this costs around £20 to £30 (US$30 to US$50).

For more advanced work, especially work involving very small components that overheat easily, a temperature-regulated or variable temperature soldering iron is needed. These usually are sold as a soldering station, comprising a soldering iron and a separate power supply. The station monitors the temperature at the soldering tip and adjusts the power output accordingly. Some stations use a magnetic switch that cycles the power on and off, using the Curie Effect; the soldering tips are designed to lose their ferromagnetic properties at a defined temperature, usually 370°C (700°F), 425°C (800°F) or 480°C (900°F), shutting off heater power until the tip cools and regains its magnetic properties. Tip temperature in such irons may fluctuate in a ~4°C (~7°F) range. Such stations are frequently used in manufacturing environments. For laboratory use, stations are available with a thermistor at the tip to monitor temperature and the temperature can be continuously varied by a rotary control. Tip temperature may also be displayed by an LED readout on the base unit. More expensive stations have an hot air pencil for desoldering purposes, as well. You can expect to pay up to £500 (US$800) for an industrial-quality soldering station.

A soldering gun, running on AC mains power, has the advantage of quickly heating up and cooling down, and can deliver significant heat to a joint. They are excellent for general electrical work, but not particularly useful for fine electronics work, as they are bulky, inhibiting accurate positioning of the tip, and supporting the weight of the transformer will cause rapid operator fatigue. Tip selection for these tools is limited to a few styles, generally blunt, for larger joints. Moreover, the tip generates an intense electromagnetic field when operating, which can damage sensitive semiconductors.

A soldering pencil, heated by a battery or refillable butane cartridge, can be used for small repair jobs in the field where AC mains power is not available, but they are not practical for continuous use.

Choosing a soldering tip
The most vital part of choosing the soldering iron is having a suitable tip on the iron. Larger tips have a higher thermal mass and hold their temperature better when working on large joints, but they are physically too big for many applications, as the tip touches more than one joint at a time. Small tips are much easier to use for most work, but they will tend to cool down when presented to a large joint.

Some tips are shaped as an obliquely cut cone, with many different sizes available. They are often called bevel or sloped tips. Typical sizes may range from 1 mm up to around 5 mm across. The advantage of this versatile tip shape is that the cut face can be used to transfer a large amount of heat to the joint, but when the edge of the face is used, it works like a fine tip for small joints or sensitive components, greatly reducing the heat transfer rate.

Soldering technique
Good soldering is all about technique and practice. It is vital that all parts are prepared properly, otherwise a defective joint will result.

Preparation
First, the solder must be prepared. As noted before, the solder you use should have a flux core. When pulling solder off the roll, you may stretch the soft tin/lead alloy past the flux, leaving a pure metal tip with no flux. This will not stick to anything very well, and may cause problems. To avoid this, always cut a few millimetres from the end of your solder with side cutters, or melt off a small piece with a hot soldering iron.

Next prepare your iron. You need a soldering iron stand, both to stop the iron from setting anything on fire and to protect the iron from being knocked to the floor by accident. Every good stand has a tray for a piece of cellulose sponge. This is kept moist and used to clean the tip of your iron. Always wet your sponge before using the iron — having it can improve your soldering immensely. Distilled water is best, but you may use tap water.

First, wait until your iron is up to temperature. Using your iron before it is hot enough will just take longer as you will have to fix the damage you did by forcing it into the joint. Once it has heated up, clean the end. Usually when you pick up an iron, its end is blackened and covered in old flux that has burnt onto the tip. This will not work as a fluxing agent, and will impair the ability of the iron to conduct heat. Add some solder to the tip (it will probably form a sphere due to the burnt coating repelling it) and wipe it onto the wet sponge. Do this until you have a shiny, silver tip to your iron. Every time you remove the iron from its stand, and also every now and again while holding the iron, clean the tip like this. The second and later times in a session you do this it will take usually only one wipe to clean the end. Always ensure that there is no excess solder on the tip before you start to solder.

Through-hole components

Through-hole mounted (THM) components are components with leads that protrude through a PCB and are soldered in place on the other side to the components.

When the PCB has copper tracks on only one side of the circuit board, the two sides of the board are usually called "solder side" and "component side".

When placing THM components on the PCB, insert the leads through the hole, and press the device down so it sits flat against the top surface of the PCB. It is often helpful to bend the leads outwards on the other side of the board to prevent the device falling out when the board is turned over for soldering. This is normally only needed for devices with two or three leads, such as axial-lead resistors or transistors.

Often, when a device is being soldered without having the leads bent to secure it mechanically, it may "sag" slightly and fall out of the hole by a millimetre or two. To prevent the components being crooked after soldering, you can tack-solder only one or two of the leads to temporarily secure it. Then, while pushing the component against the circuit board from the other side, reheat the joint(s) and allow the solder to solidify. Finish soldering the remaining leads, and, if needed, return to the original joint(s) to add solder as needed. This technique is particularly useful with DIP packages and similar multi-lead packages.

SMT components
Surface-mount technology (SMT) has been gradually replacing older components with wire leads. Some special tools and techniques are used to solder and unsolder SMT components.

Safety
Always wear safety glasses or goggles with plastic or tempered glass lenses while soldering, to protect your eyes from flying droplets of hot, liquid solder.

The tip of the soldering iron is, by design, very hot, exceeding 370°C (700°F). Avoid letting the tip touch skin, clothing, or anything that might melt, scorch, or burn. Use a proper soldering iron holder when the iron is powered on. These offer a convenient place to rest the iron and keep anything from touching the hot tip. The small plastic-and-wire stands that come with inexpensive soldering irons can be dangerous, as they leave the tip exposed and the iron can easily roll off the stand.

The flux in solder (as well as additional flux applied to the joint) will boil and burn when exposed to the heat of the soldering iron. Although smoke from rosin flux isn't particularly toxic, it is an irritant to the lungs and breathing passages, and extended exposure can lead to health problems. You can avoid breathing the smoke from flux by not "hovering" over your work, setting up a fan to keep your face "upwind" of the work, or by using a fume extractor specifically designed for soldering stations. Always solder in an area with adequate ventilation to keep the fumes from accumulating. A room with windows that open is preferred.

The lead in solder will not typically get hot enough to vaporize and become airborne. However, you will end up with lead on your hands after handling solder, so it is necessary to wash your hands with soap and water afterwards. Lead is toxic and can cause a variety of health problems. Children and pregnant women should avoid all contact with lead due to the severe developmental problems it causes.

Practical Electronics modules

 * Desoldering

Wikipedia articles

 * Soldering
 * Solder
 * wikipedia:Flux

title: Practical Electronics/Soldering


text:
User talk:125.236.44.49

Thanks for experimenting with the page MapleStory/Monsters on Wikibooks. Your test worked, and has been reverted or removed. Please use the sandbox for any other tests you want to do. Take a look at the welcome page if you would like to learn more about contributing to our project. Thanks. Az1568 23:58, 10 September 2006 (UTC)

title: User talk:125.236.44.49


text:
User talk:Wikijeff

Thanks
Hi, Wikijeff. Thanks for helping on the Hebrew book. I wasn't aware of the multi-language templates. That will be very helpful. Thank you! --CocoaZen 00:27, 11 September 2006 (UTC)

please correct my English mistakes in the Hebrew textbook
Hi Wikijeff,

I've begun working on a Media Hebrew Reference Guide based on excerpts taken from the three major Hebrew newspapers published in Israel. I'm branching this project from inside the current Hebrew textbook. Since i'm not a native English speaker, i'd appreciate it if you could go over my additions and correct any language or style mistakes i've made.

Thanks, Itayb 17:12, 10 February 2007 (UTC)

title: User talk:Wikijeff


text:
Category:Multilingual support templates

These templates help with text in different alphabets. To add an article to this category, add to that page.

title: Category:Multilingual support templates


text: Template:Hebrew/Large

title: Template:Hebrew/Large


text:
User talk:24.79.143.15

This message is regarding the page Workbook Canada - Citizenship test. Please refrain from adding nonsense to Wikibooks. It is considered vandalism. If you would like to experiment, use the sandbox. Az1568 00:44, 11 September 2006 (UTC)

title: User talk:24.79.143.15


text:
User talk:63.22.199.197

Thanks for experimenting with the page Super Mario World on Wikibooks. Your test worked, and has been reverted or removed. Please use the sandbox for any other tests you want to do. Take a look at the welcome page if you would like to learn more about contributing to our project. Thanks. Az1568 00:52, 11 September 2006 (UTC)

title: User talk:63.22.199.197


text:
WebObjects/Web Applications/Deployment/FreeBSD

Install Java
Follow the FreeBSD instructions to install the native Java. I (Ari Maniatis) am still using 1.4.2 on our deployment servers, but it is likely that 1.5.x will work fine.

This should also cause the javavmwrapper port to be installed. This makes it easy to switch between different Java VM versions.

Install WebObjects
Install gtar (the FreeBSD tar doesn't seem to work for me):

portinstall gtar

Mount the WebObjects CD at /mnt/cdrom and then:

cd /mnt/cdrom/Deployment/SOLARIS ./install.sh -license B-111-AAA-111-AAA-111-AAA-111-AAA-111 -altjvm /usr/local/bin/javavm -adaptorsOnly NO -minimalInstall NO -cgibin /usr/local/www/cgi-bin -docroot /usr/local/www/data -woroot /usr/local/apple -gnutar /usr/local/bin/gnutar

To find your license key, look in your developer installation and find it at:

/System/Library/Frameworks/JavaWebObjects.framework/Resources/License.key

The system then needs to know where NEXT_ROOT lives:

edit /etc/profile and add: NEXT_ROOT=/usr/local/apple export NEXT_ROOT OS= FREEBSD export OS

Log out and then back in to make sure this takes effect.

Apply updates
If necessary, you can apply updates like this:

sh patcher.sh -install WO51Solaris522.tar.gzip

You can download the patcher.sh shell script and the gzip update from Apple's website.

Install the Apache adaptor

 * Download the binary or
 * Compile it yourself

TODO: I've tried but failed to get this working with Apache2

Configure Apache
Add the configuration file: cp $NEXT_ROOT/Developer/Examples/WebObjects/Source/Adaptors/Apache/apache.conf /usr/local/etc/apache/webobjects.conf

Add the line: Include /usr/local/etc/apache/webobjects.conf
 * before* LoadModule rewrite_module

Add the line: AddModule mod_WebObjects.c
 * after* AddModule mod_rewrite.c

Edit the configuration file at /usr/local/etc/apache/webobjects.conf:

comment out the line "AddModule mod_WebObjects.c" replace LOCAL_LIBRARY_DIR/WebServer/Documents with /usr/local/www/data

Create a startup scripts for wotaskd and javamonitor
Create /usr/local/etc/rc.d/110.wotaskd.sh
 * 1) !/bin/sh

NEXTROOT=/usr/local/Apple

case "$1" in       start)                if [ -x /usr/local/bin/mysqld_safe ]; then                export PATH=/usr/local/bin:$PATH                export NEXT_ROOT=${NEXTROOT}                ${NEXTROOT}/Library/WebObjects/JavaApplications/wotaskd.woa/wotaskd &                        echo -n ' wotaskd'                fi                ;;        stop) echo "not supported" ;;       *)                echo ""                echo "Usage: `basename $0` { start | stop }"                echo ""                exit 64                ;; esac

Create /usr/local/etc/rc.d/150.javamonitor.sh
 * 1) !/bin/sh

PATH=/usr/local/bin NEXTROOT=/usr/local/Apple

case "$1" in       start)                        export PATH=/usr/local/bin:$PATH                        export NEXT_ROOT=${NEXTROOT}                        ${NEXTROOT}/Library/WebObjects/JavaApplications/JavaMonitor.woa/JavaMonitor -WOPort 6666 &                        echo -n 'JavaMonitor'                        ;;        stop) echo "not supported" ;;       *)                echo ""                echo "Usage: `basename $0` { start | stop }"                echo ""                exit 64                ;; esac


text:
Hebrew/Aleph-Bet/3

 Aleph-Bet Lesson 3 —

Welcome to the third lesson of the Hebrew alphabet! In this lesson you will learn the two most common Hebrew letters - and, and two new niqqud symbols - segol and ħiriq.

Letters
The two letters (and four forms) you will learn now are the most common in the Hebrew language:

Mem
The thirteenth letter in the Hebrew alphabet is Mem. It makes the "m" sound (IPA: /m/, "m" as in "mother"). Like Nun, when it is at the end of a word, it changes form. This final form is known as Mem Sofit -.

Shin
The penultimate letter in the Hebrew alphabet is Shin. It has two forms:
 * When the dot above the letter is on the right - it's called Shin and it makes the "sh" sound (IPA: //, "sh" as in "ship"). This is more common.
 * When the dot above the letter is on the left - it's called Sin and it makes the "s" sound (IPA: /s/, "s" as in "safe").

Vowels
You will now learn another way to express the "e" sound as well as the exclusive vowel for the "i" sound:

Segol
The segol is the three dots under the Bet.

Like Tsere, it produces the "e" sound (IPA: /e/, "e" as in "bet").

Ħiriq
The ħiriq is the dot under the Bet.

It produces the "i" sound (IPA: /i/, "i" as in "ski").

Words
Thanks to the letter Mem and the symbol Segol, we can complete our collection of 2nd person pronouns (all appearing as "you" in English)!

atah you (masculine, singular) at you (feminine, singular) atem you (masculine, plural) aten you (feminine, plural)

You might notice that all of them begin with at. Some more pronouns:

hem they (masculine) hen they (feminine)

So we have daughter, son, and father. Now we need the mother.

em mother (feminine, singular) ima mom (feminine, singular, informal)

Other new words:

mah what shem name (masculine, singular) shabbat sabbath, Saturday (feminine, singular)

Summary
In this lesson, you have learned: Practice what you've learned in the exercises.
 * The Hebrew letters and forms Mem, Mem Sofit , Shin and Sin.
 * The niqqud symbols Segol (ֶ) and Ħiriq (ִ).
 * The 2nd person pronouns in Hebrew.
 * The words and.

Next lesson: Aleph-Bet 4 >>>

title: Hebrew/Aleph-Bet/3