text:
ACE+TAO Opensource Programming Notes/Create an event consumer

Discussion
This event client is designed to accept the events from the previously defined event server. The main difference between the server, where you can simply stuff some message in a CORBA::Any object and sent it to the event dispatcher, the client needs to overload the POA_CosEventComm::PushConsumer class. Specifically, the push and disconnect members need to be overridden.

main.cpp

 * 1) ifdef HAVE_CONFIG_H
 * 2) include
 * 3) endif

 * 1) include
 * 2) include
 * 3) include "eventsinkC.h"
 * 4) include "eventsinkconsumer_i.h"

using namespace std;

//#include "acbc.h"

int main(int argc, char *argv[]) { // Initialize the ORB. CORBA::ORB_var orb = CORBA::ORB_init(argc, argv, "whatever"); CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA"); //Now we need a reference to the naming service CORBA::Object_var naming_context_object = orb->resolve_initial_references ("NameService"); CosNaming::NamingContext_var naming_context = CosNaming::NamingContext::_narrow (naming_context_object.in ); CosNaming::Name ec_name; ec_name.length(1); ec_name[0].id = CORBA::string_dup("CosEventService"); //TAO Specific

// Resolve the binding to the event channel object reference. CosEventChannelAdmin::EventChannel_var channel = CosEventChannelAdmin::EventChannel::_narrow(naming_context->resolve(ec_name)); //     resolve_name( //      naming_context, ec_name); //Instanciate the servant EventSinkConsumer_i servant(orb.in); //Register it with the root POA naming_context_object = orb->resolve_initial_references("RootPOA"); PortableServer::POA_var poa = PortableServer::POA::_narrow(naming_context_object.in); PortableServer::ObjectId_var oid = poa->activate_object(&servant); CORBA::Object_var consumer_obj = poa->id_to_reference(oid.in); CosEventComm::PushConsumer_var consumer = CosEventComm::PushConsumer::_narrow(consumer_obj.in); //Get a consumer admin object for the event channel CosEventChannelAdmin::ConsumerAdmin_var consumerAdmin = channel->for_consumers; //Get a proxy supplier from the consumer admin CosEventChannelAdmin::ProxyPushSupplier_var supplier = consumerAdmin->obtain_push_supplier; //Connect to the proxy push supplier, passing the push consumer object ref to it supplier->connect_push_consumer(consumer.in); //Activate the POA via its POAManager PortableServer::POAManager_var poa_manager = poa->the_POAManager; poa_manager->activate; cout << "Starting to receive events" << endl; //Start the event loop orb->run; orb->destroy; return EXIT_SUCCESS; }

eventsinkconsumer_i.h

 * 1) ifndef EVENTSINKCONSUMER_I_H
 * 2) define EVENTSINKCONSUMER_I_H

 * 1) include
 * 2) include "eventsinkC.h"
 * 3) include "eventsinkI.h"

/** The class responsible for specializing the POA_CosEventComm::PushConsumer interface

@author Evan Carew  class EventSinkConsumer_i : public virtual POA_CosEventComm::PushConsumer { CORBA::ORB_var orb_; public: EventSinkConsumer_i(CORBA::ORB_ptr orb); virtual void push( const CORBA::Any &data) throw(CORBA::SystemException); virtual void disconnect_push_consumer throw(CORBA::SystemException); };

 * 1) endif

eventsinkconsumer_i.cpp

 * 1) include "eventsinkconsumer_i.h"

using namespace std;

/** \fn EventSinkConsumer_i::EventSinkConsumer_i(CORBA::ORB_ptr orb) * Just make a copy of the orb pointer in the constructor. */ EventSinkConsumer_i::EventSinkConsumer_i(CORBA::ORB_ptr orb) : orb_(CORBA::ORB::_duplicate(orb)) {}

/** \fn EventSinkConsumer_i::push( const CORBA::Any &data) * Override the push op */ void EventSinkConsumer_i::push( const CORBA::Any &data) throw(CORBA::SystemException){ //Extract the event data from the Any accepted *bill_event; if(data >>= bill_event) cout << "Bill Event Data: Bill = " << bill_event->bill << " Status = " << bill_event->status << " Command = " << bill_event->command << endl; }

/** \fn EventSinkConsumer_i::disconnect_push_consumer * Override the disconnect operation */ void EventSinkConsumer_i::disconnect_push_consumer throw(CORBA::SystemException){ //Deactivate this object CORBA::Object_var obj = orb_->resolve_initial_references("djb"); PortableServer::Current_var current = PortableServer::Current::_narrow(obj.in); PortableServer::POA_var poa = current->get_POA; PortableServer::ObjectId_var objectId = current->get_object_id; poa->deactivate_object(objectId.in); }

eventsink.idl
Actually, this is a copy of eventsource.idl. struct accepted{ unsigned long bill; unsigned long status; unsigned long command; };

Link Line Details
-lTAO_CosEvent_Skel -lTAO_CosEvent -lTAO_PortableServer -lTAO_CosNaming -lTAO_AnyTypeCode -lTAO -lACE


text: Template:Hidden

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

title: Template:Hidden


text:
ACE+TAO Opensource Programming Notes/Dealing with IORs

As described earlier, the raw IOR string for tying together client and server isn't the preferred method to getting the two sides to talk together. In a production environment, the usual method is to use a naming service. This serves both as a way to advertise a location for a service, and as a method to keep the effective IOR of the service constant. You might have noticed, had you played with the previous server example more than once that the IOR string tended to change. With this method, you can ensure both consistency and readability.

The infrastructure used by CORBA programs to perform such address registration and lookups is the naming service. For TAO, the naming service is started with several command line args. In the examples below, the arg "-ORBEndPoint" is used to define where the service will listen, and the arg "-ORBDaemon" is designed to force the daemon to actually act like a daemon. Oddly enough, none of the services (daemons) you will be compiling with TAO will actually act like daemons, unless you use this optional arg.

The endpoint is critical to running any TAO service or compiled client/server app. If you don't supply one, the default endpoint is the multicast endpoint. This default endpoint is described as being useful for apps where performance isn't an issue, or for testing. That being said, this author couldn't get the multicast IIOP endpoint to work on a stock Linux FC4 system, even though the Linux system swore that multicasting was up and running. I was able to verify the bug by running the multicast test app under the ACE framework test directory. To ensure that anyone reading this is able to get something up and running, we will therefore set up a client with the explicitly defined endpoint of "localhost".

There are two basic forms of this endpoint, there is the service advertising its services, and the client trying to find a service. To make this discussion intuitive, we will assume that in each example, a naming service server is running and reachable from your test box. To get the naming service started, try the following: Naming_Service -ORBEndPoint iiop://localhost:12345 -ORBDaemon

This should set up your naming service on port 12345 on the localhost interface. To test that this is up and working, try the following: nslist -ORBInitRef NameService=corbaloc:iiop:localhost:12345/NameService

This should then produce the following output: Naming Service: -

This shows that your naming service is up and running, but reporting no services yet. To see what a service looks like, try the following command to start the event service (which we will be using in later examples): CosEvent_Service -ORBInitRef NameService=corbaloc:iiop:localhost:12345/NameService -ORBDaemon

Now, when you run nslist again, you will see the following output: Naming Service: - CosEventService: object reference:   Protocol: IIOP,   Endpoint: 10.0.0.53:32802

Finally, we have a working set of servers we have connected together with IIOP endpoints. When you connect your clients and servers together, you will be using the same process... start the naming server, possibly the event service (or others) and then start in with your clients and servers. For linux, the people associated with the ACE+TAO project have provided RPM packages with script files designed to interract with linux's boot facilities which will start the naming service (and the others) automatically.


text: Category:Book:Bioinformatics

title: Category:Book:Bioinformatics


text: Category:Book:Computational Physics

title: Category:Book:Computational Physics


text:
ACE+TAO Opensource Programming Notes/Starting the basic services

As discussed in the previous section, Dealing with IIOP Endpoints, the naming service is one of the basic services. The other basic services you will be needing for most purposes are: CosEvent_Service Notify_Service Scheduling_Service

On most platforms, you can start these with the following command lines by hand: Naming_Service -ORBEndPoint iiop://localhost:12345 -ORBDaemon CosEvent_Service -ORBInitRef NameService=corbaloc:iiop:localhost:12345/NameService -ORBDaemon Notify_Service -ORBInitRef NameService=corbaloc:iiop:localhost:12345/NameService -ORBDaemon Scheduling_Service -ORBInitRef NameService=corbaloc:iiop:localhost:12345/NameService -ORBDaemon

Where the endpoint determines where the listener for the service will hang-out, and the ORBDaemon option tells the service to run as a background daemon. In the Linux environment, these services can also be started automatically in the background through the boot time scripts found in /etc/rc.d. One of the developers on the list server has been good enough to provide RPMs of ACE+TAO complete with the boot time scripts.


text: Category:Book:Cryptography

title: Category:Book:Cryptography


text:
ACE+TAO Opensource Programming Notes/Create a client

Discussion
So, unlike the server, the client doesn't involve implementing any code generated by the IDL. In the client, we simply instantiate a copy of the factory (using as an address the IOR string we generated with the server) and call its functions. This is all it takes for a basic client.

In the following code, the first argument to the program gets used as the address argument to TAO's orb to find our server. We are using the string generated earlier much like someone would use an IP address/port combination to find a host and application on the internet. While we will discuss it later, this analogy is somewhat apt because, on the internet, we usually prefer to use host names (using DNS) and well known services (ports) to access our services. In CORBA land, the same is true, and we will be discussing that later.

After acquiring the factory object from the orb, we then downcast the generic object to our My_Factory_var object as generated by the IDL. Note that we aren't downcasting it to "My_Factory", but rather "My_Factory_var". TAO, and perhaps CORBA seem to have adopted a standard of using XXX (as defined in your IDL) as the class you use to manipulate the ORB, and XXX_var (as generated by the IDL) as the repository for your object, as generated by XXX.

Now that you have generated your application specific factory object from the generic one received from the ORB, you may proceed to use these two objects as you would any normal C++ object. Just remember to keep in mind the type of data you are getting back from your queries, and or what type of data you are sending. Suffice it to say that inattention to these details will cause memory leaks.

Finally, destroy the ORB. While this is quite a simple application, and technically the destructor isn't needed, its still a good idea to get in the practice as leaving these objects hanging will cause all sorts of problems with distributed programs.

ace_service.idl
// Forward declare interface Widget;

interface My_Factory {   // = TITLE //  A factory class for the widget interfaces //   // = DESCRIPTION //  Return the Widget interfaces based on their names // Widget get_widget (in string widget_name); };

interface Widget {   // = TITLE //  A simple interface to query the name and price of a widget //   // = DESCRIPTION //  Return the price and name of a single widget //

readonly attribute string full_name; // Get the name.

double price ; // Get the price

};


text:
ACE+TAO Opensource Programming Notes/Advertise your service on a naming service

Discussion
So the previous client/server pair were a bit clunky. What they lacked in elegance, they gained in brevity. This client/server example will show how to edit the previous examples so that they use the naming service and nolonger rely on the clunky manual IOR method of addressing. As a side note, these IOR strings are only good for the length of time the server is running. Since each new process generates a unique IOR string, storing them in a file for client reuse just isn't feasible, therefore, we use the naming service, which acts like a DNS for our services.

So, to make this work, we need to get a reference to a naming service, create a name with which to bind our service under, and register that name with the naming service. The following lines of code are what we will need: Placing this code above the "orb->run" line of the previous server will get it on the naming server. For the full source code, see the following listing

main.cpp
So, as you can see, the main difference here is the addition of a new include for the naming service and the code snipit mentioned above. The other portions of the server remain exactly the same.


text:
ACE+TAO Opensource Programming Notes/Attaching your applications to the core services

Ok, so we now have a client and server along with services... let's wire them up.

If you have an already compiled server from one of the previous examples, you'll want to start that up first and have it advertised on the naming service. To do that, you'll need to tell the server you wrote the IOR of the naming service. TAO allows you two ways to do this. The first is to create an environment variable "NameServiceIOR" which you assign the IOR you used when you started the NamingService. The other method, is to put the IOR on the command line. The IOR from the example below is the string starting with "corbaloc" and continuing to the end of the line. The latter option is my preferred method to get a server started.

./YourServer -ORBInitRef NameService=corbaloc:iiop:yoyodyne.com:12345/NameService

The -ORBInitRef option is simply passed to the CORBA::ORB_init function in the opening lines of your application, so you could optionally pass this in directly to the function, thus obviating the need for this long command line. In practice, however, I've always used this long command line form as it makes it easier to move the app around.

To start the client side, using the command line from above is fine.

./YourClient -ORBInitRef NameService=corbaloc:iiop:yoyodyne.com:12345/NameService

One final note unrelated to connecting your apps into the framework. The ACE+TAO framework, because it was designed to work on Microsoft's platform, comes with a non-standard way to start up the app. If you want to run your shiny new app as a daemon, you need to add -ORBDaemon to the command line. If you are doing this under linux, don't try the daemon C function call in your source, it'll only serve to confuse things.


text:
Cookbook talk:Inarizushi (Stuffed Sushi)

This recipe is for the fukusazushi omelette wrapper. Users of the cookbook should be aware that the accompanying illustration shows inari made with a tofu wrapper, which is overwhelmingly the most common form of inarizushi. --Haruo 18:44, 24 June 2006 (UTC)
 * An additional caveat: this is only a recipe for the wrapper. The instructions for making the filling (basically just sushi rice) are not included in this recipe. --Haruo (talk) 00:23, 1 August 2009 (UTC)


text:
Talk:GCSE Science/Electricity multiple choice

Organization
I have merged questions 5-13 onto one page. If anyone would prefer questions on separate pages, please tell me and I will revert my changes immediately. --hagindaz 19:04, 24 June 2006 (UTC)


text:
GCSE Science/Electricity multiple choice practice question 8 answer 3

Well done this is the correct answer.

Recall by Ohm's Law that V=IR and then V/I = R. Observe on the graph that as voltage increases, current increases also. So as these values increase, their quotient must remain relatively constant. So the resistance remains relatively constant.Hence a straight line graph.

On to the next question>>


text:
GCSE Science/Electricity multiple choice practice question 8 answer 2

Sorry this is the wrong answer.

From Ohm's Law

 * R=V/I

But V/I is also the slope (or gradient) of the line on the graph. So with a constant slope, we must have a constant resistance.

Go back and try again>>


text:
GCSE Science/Electricity multiple choice practice question 8 answer 1

Sorry this is the wrong answer.

From Ohm's Law

 * R=V/I

But V/I is also the slope (or gradient) of the line on the graph. So with a constant slope, we must have a constant resistance.

Go back and try again>>


text:
Category:Book:Computers for Beginners

ru:Категория:Компьютеры для начинающих

title: Category:Book:Computers for Beginners


text: Category:Book:Conworld

title: Category:Book:Conworld


text: Category:Book:Concepts of Computer Graphics


text: Category:Book:Conic Sections

title: Category:Book:Conic Sections


text:
User:Begs~enwikibooks

Just an interested contributor.

Wikipedia entry if curiosity is unbearable. http://en.wikipedia.org/wiki/User:Begs

title: User:Begs~enwikibooks


text: Category:Book:Control Systems

title: Category:Book:Control Systems


text: Category:Book:Corset

title: Category:Book:Corset


text: Category:Book:Dialectical Behavioral Therapy


text:
Category:Book:Dutch

ja:Category:オランダ語

title: Category:Book:Dutch


text:
The Holocaust

The book looks at the situation in which the Holocaust was able to take place. It will look into those involved and where and when important events took place, to try and establish a clear picture of the extent of what has happened. What happened after the war and what ongoing impact will the events of the Holocaust have now?

Contents

 * 1) The roots of anti-semitism in Europe
 * 2) Untermensch and Anti-Semitic terminology
 * 3) /Anti-Semitic Policy/
 * 4) /Eugenics/
 * 5) The rise of Fascism
 * 6) A 'Final Solution'
 * 7) /Victims/
 * 8) Homosexuals
 * 9) Romanies
 * 10) /Features of the Holocaust/
 * 11) Concentration and Labor Camps (1933-1945)
 * 12) Euthanasia (1939-1941)
 * 13) Ghettos (1940-1945)
 * 14) Extermination camps (1942-1945)
 * 15) Death marches and liberation (1944-1945)
 * 16) /Resistance/
 * 17) /Perpetrators and collaborators/
 * 18) /Historical and philosophical interpretations/
 * 19) /Aftermath/
 * 20) /Holocaust denial/
 * 21) /The Impact/
 * /Bibliography/
 * /Further Reading/

title: The Holocaust


text:
Cookbook:Eggplant Parmesan (Melanzane alla Parmigiana) II

Melanzane alla parmigiana is a typical Italian dish, existing in different forms in most parts of Italy. Northerners claim it as their own because of the name. Southerners, in particular Sicilians, claim that it originated in the south and that "Parmigiana" is a misunderstanding for "Palmigiana", which is a type of shutter, alluding to the way in which the eggplant slices are laid. There are some variations (including a dessert version with chocolate) but mostly the ingredients are: eggplants, tomato sauce, basil leaves, mozzarella, and, obviously, Parmesan cheese.

Ingredients

 * 2 kg (4 lb) eggplants
 * 700 g (24 oz) fresh cooking tomatoes, or one large or two medium cans of plum tomatoes
 * 1 kg (2 lb) cows' milk mozzarella cheese, known in Italy as fiordilatte
 * ½ large or 1 medium onion, sliced
 * Olive oil
 * Fresh basil leaves
 * Parmesan or Grana Padano cheese

Procedure

 * 1) Cut eggplants lengthwise in ¼ inch (0.75cm) thick slices, and put them in a plate covered by plenty of salt for about 1 hour. Wash off the excess salt and dry the slices with a paper towel.
 * 2) Start cooking the onion slices in olive oil; when the onion is soft add drained whole tomatoes and mash them with a fork. If the tomatoes are watery, add a small can of tomato paste to thicken the sauce. Add 2 leaves of basil and simmer for about 20 minutes.
 * 3) While the tomato sauce is cooking, fry the eggplant slices as follows. Fill a frying pan (cast iron if you have it) with ½ inch (1 cm) of olive oil and heat. When the oil is hot, start frying the eggplant slices a few at a time so that they do not overlap in the pan. Cook until golden, flipping once. Remove the eggplants and put them in a drainer so the excess oil can drain. Repeat until all the slices are cooked.
 * 4) To assemble, start with a thin layer of sauce in the bottom of a greased ovenproof baking pan or casserole. Then proceed with a layer of eggplants with their edges slightly overlapped and no voids. Add basil leaves and a layer of sliced mozzarella. Continue alternating layers until the eggplant is used up, and finish topping with tomato sauce and grated Parmesan or grana.
 * 5) Bake in the oven for about 40 minutes at 350°F (180°C). Serve really hot. If you are lucky enough to have leftovers, they taste even better the day after.


text:
Java Programming/Keywords/goto

is a reserved keyword, presently not being used.

title: Java Programming/Keywords/goto


text:
Talk:Bartending/Cocktails/Piña Colada

Perhaps the Collins glass should be listed under a new section entitled "equipment" or "utensils".

title: Talk:Bartending/Cocktails/Piña Colada


text:
Bartending/Cocktails/Piña Colada

Ingredients:

 * 1) 3 oz Light rum
 * 2) 3 tbsp Coconut milk
 * 3) 3 tbsp Pineapple, crushed
 * 4) 2 cups Crushed ice

Instructions

 * 1) Put all ingredients into an electric blender.
 * 2) Blend at a high speed for a short length of time.
 * 3) Pour into a Collins Glass and serve with a straw.
 * 4) Add decorations (e.g. wedge of pineapple, maraschino cherry, tiny umbrella) if wanted.

Variations

 * 1) Staten Island Ferry

title: Bartending/Cocktails/Piña Colada


text:
Chess Opening Theory/1. d4/1...e6

1...e6
The key move of the Horwitz Defense. The main purpose of this move is to transpose to mainline openings without immediately showing your opponent your cards.

At this point, it is more likely to transpose into a myriad of 1. d4 openings. What is unique about this move is that it is somewhat of an invitation for white to enter the French.

White can play almost anything at this point, but 2. c4, 2. Nf3 and 2. e4 are the more common replies.

Theory table
.

'1. d4 e6'

title: Chess Opening Theory/1. d4/1...e6


text:
Talk:Java Programming/Collection

This section needs rewrite
IMHO This needs attention. I'm not sure it can be fixed without a complete rewrite. It is not written well (must be someone for whom English is not their fist language?), and the structure is not good. There is some good content in there, and the person that wrote it probably does have a grasp on collections, but it needs some attention.
 * I have changed the status of this page to 25% . I will be rewriting some of the sections to provide the reader with delightful insights. Thanks for notifying the problem. Remember, do sign off whenever you add a comment with ~ . - Arunreginald 15:04, 2 November 2006 (UTC)
 * I share the concern of the anonymous commentor. The article contains good information but unfortunately lacks a logical structure. Some suggestions in terms of content:
 * Generics is mentioned but it should be made clear that you used to have the casting problems, not with generics. The way it is written now suggests that it's the problem when using generics.
 * I have fixed this point.
 * More basic coding examples for each group including using generics.
 * I have added code.
 * Explain about 'syncronized' earlier in the article instead of in the end. Since you use it extensively in the article, it's only confusing now if you don't know what it means.
 * I have added a section but this section needs to be completed.
 * Separate the in depth info like the comparison troubles with sets.
 * The package prefixes before each interface and implementation does not improve the readability of the article. Consider removing them or including them in a different manner.
 * I have used colors.
 * The LinkList pointer bit should realy need some more explaination.
 * Consider including a table like in 'The Java Tutorials - Collections' by Josh Bloch. This would provide a clear overview of the posibilities.
 * remain basically unexplained.
 * Some questions people might have after reading the article that might need answering:
 * Should or shouldn't we still use the old style, i.e. not using generics in all cases?
 * It should be OK now.
 * If sets don't allow duplicates in the first place, why should we check if there's a duplicate ourselfs?
 * You talk about 'syncronized' and 'non-syncronized' as if it's something different then 'thread safe', is it?
 * Mentioned.
 * In examples like  you make   of the type  . Why not make it   instead? E.g.   or   even. Prodoc (talk) 08:53, 6 March 2009 (UTC)
 * This point is explained in the page: It lets you switch from one implementation to another easily. Ftiercel (discuss • contribs) 02:44, 21 October 2012 (UTC)

Chapter names
I notice that the navigation of this page is displaying the link for Java Aggregate classes but the Java Aggregate is not listed in the TOC. Shchung (discuss • contribs) 06:41, 17 September 2014 (UTC)
 * I have renamed the chapter. Ftiercel (discuss • contribs) 12:58, 18 September 2014 (UTC)

title: Talk:Java Programming/Collection


text:
User:Nerocyan

Hello! I am a student from South Korea.

[User page in Korean Wikipedia]

title: User:Nerocyan


text:
Haskell/Getting set up

Installing Haskell
Haskell is a programming language, i.e. a language in which humans can express how computers should behave. It's like writing a cooking recipe: you write the recipe and the computer executes it.

To use Haskell programs, you need a special program called a Haskell compiler. A compiler takes code written in Haskell and translates it into machine code, a more elementary language that the computer understands. Using the cooking analogy, you write a recipe (your Haskell program) and a cook (a compiler program) does the work of putting together actual ingredients into an edible dish (an executable file). Of course, you can't easily get the recipe from a final dish (and you can't get the Haskell code from the executable after it's compiled).

To get started, visit haskell.org/downloads for the latest instructions. The current recommended way is to use GHCup. Use it to install the latest recommended version of GHC,  (not  ), and the Haskell language server. You should use  to install any Haskell library you need. We will cover using  in depth in Haskell/Packaging

To just test some Haskell basics without downloading and installing, there is a playground which includes a few packages by default. Most instructions here on the Wikibook will also work on the playground, though it doesn't accept user input.

First code
After installation, we will do our first Haskell coding with the program called GHCi (the 'i' stands for 'interactive'). Depending on your operating system, perform the following steps:

 * On Windows: Click Start, then Run, then type 'cmd' and hit Enter, then type  and hit Enter once more.
 * On MacOS: Open the application "Terminal" found in the "Applications/Utilities" folder, type the letters  into the window that appears, and hit the Enter key.
 * On Linux: Open a terminal and run.

You should get output that looks something like the following: GHCi, version 8.10.7: http://www.haskell.org/ghc/ :? for help Prelude>

The first bit is GHCi's version, and tells your how to get help in GHCi. The  bit is known as the prompt. This is where you enter commands, and GHCi will respond with their results. The prompt also tells you that the current loaded module is, which gives you access to most of the built-in functions.

Now let's try some basic arithmetic:

These operators match most other programming languages:   is addition,   is multiplication, and   is exponentiation (raising to the power of, or $$a ^ b$$). As shown in the second example, Haskell follows standard order of math operations (e.g. multiplication before addition).

Now you know how to use Haskell as a calculator. Actually, Haskell is always a calculator — just a really powerful one, able to deal not only with numbers but also with other objects like characters, lists, functions, trees, and even other programs (if you aren't familiar with these terms yet, don't worry).

To leave GHCi once you are done, use  (or just  ):

GHCi is a powerful development environment. As we progress, we will learn how to load files with source code into GHCi and evaluate different parts of them.

Assuming you're clear on everything so far (if not, use the talk page and help us improve this Wikibook!), then you are ready for next chapter where we will introduce some of the basic concepts of Haskell and make our first Haskell functions.

title: Haskell/Getting set up


text:
User:Pfctdayelise/Uyghur/Introduction/Resources

This is an annotated list of existing resources that can support your Wikibooks learning as well as extend it.

Books
There are very few books available in English about Uyghur, which is partly a motivating factor for this Wikibook.

Instructional

 * Spoken Uyghur by Reinhard Hahn (1991, University of Washington Press, ISBN 0295986514). Amazon indicates that it's going to be reprinted in October 2006. Has 15 lessons with dialogues in Arabic script, Latin script and English translation. Main script used in vocabulary lists is Latin. Has a lengthy and detailed introductory section on the "principles of morphophonology".

 * Introduction to Modern Uyghur by Hamit A. Zakir, (2007, Xinjiang University Press, ISBN) 7563120777). Available in private bookstores in Urumqi (best bet, ones near Xinjiang University, specifically Ghalibiyet Kitabxanisi). 28 lessons, Arabic script, instruction and explanation in English.

Phrasebooks

 * [unseen] Lonely Planet Central Asia Phrasebook by Justin Jon Redelson (1998, Lonely Planet Publications, ISBN 0864424191). Covers five languages, one of which is Uyghur. Reportedly the chapter on Uyghur is better than the others, also reportedly only has transliterations, not original scripts.

Dictionaries

 * An Uyghur-English Dictionary by Henry Shwarz (1992, East Asian Research Aids and Translations, ISBN 0914584898). A large dictionary that suffers from only having Latin script lookup and no Arabic script at all, save the alphabet on the inside cover. Has terminological lists in an appendix on these topics: Agriculture, astronomy, botany, chemistry, clothing, food, geography, geology, grammar & linguistics, history, literature, mathematics, medicine, military, music, philosophy, physics, physiology, religion, sports and zoology.
 * [unseen] Inglizcha-Uighurcha lughat: English-Uighur dictionary by Anvar Paizulla (1998, Shinjang Khalq Nashriyyati, ISBN 7228007395).
 * List of further dictionaries

Culture

 * A reasonably complete list exists here.

United States

 * University of Washington Central Asian Studies in the Department of Near Eastern Languages and Civilization: Uighur Studies. They have taught Mordern and Old Uighur since the 1970s and have an exchange agreement with Xinjiang University.
 * Indiana University, Bloomington Department of Central Eurasian Studies offers introductory, intermediate and advanced Uyghur.
 * The University of Kansas offers Uyghur through its Center for East Asian Studies.
 * Columbia University School of International Public Affairs lists Uyghur as one of the courses it offers.
 * Berkeley reportedly offers Uyghur, but I couldn't find any mention of it...

See also the Less Commonly Taught Languages database (search for 'Uighur'), and the American Association for Teachers of Turkic (may list other relevant schools in the future).

China
They probably all teach in Chinese.
 * Xinjiang University （新疆大学）, Xinjiang website
 * Normal University of Xinjiang （新疆师范大学）, Xinjiang
 * Kashgar Pedagogical College, Xinjiang
 * Ili Pedagogical College, Xinjiang
 * Central University for Nationalities (中央民族大学), Beijing: Department of Turkic Languages and Cultures
 * Northwestern Nationality Institute, Gansu
 * Shaanxi Normal University, Shaanxi: Centre for Nationality Studies

Learning

 * http://crl.nmsu.edu/say/uighur/audio/ Some basic phrases with sound files.
 * http://www.uighurlanguage.com/ Large and somewhat scattered. Mostly in Latin script. Some good vocabulary lists.

Sound

 * http://languagelab.bh.indiana.edu/uygur.html Indiana University's recordings of lessons from Spoken Uyghur by Rienhard Hahn. Available in .ra and .mp3 formats.

Uyghur content

 * Radio Free Asia (Arabic script) (also Latin and Cyrillic scripts) Includes broadcasts in Uyghur (just click something that looks like a speaker symbol :)) in streaming m3u.
 * Broadcasts are also indexed in English at http://www.podcast.net/show/72344
 * http://www.yulghun.com/
 * http://www.diyarim.com/
 * http://www.biliwal.com/
 * http://www.uighursoft.com/ A software company
 * http://www.ukij.org/ Computer something or other

Dictionaries

 * http://dict.yulghun.com/
 * http://www.uyghurdictionary.org/ "What we can offer you at this time is a basic list of 70,120 Uyghur entries, the etymology of words of non Turkic origin and indications of vowel length as well as attempted English translations." Search in romanized script, Cyrillic or Arabic, or English.

Software

 * Oyghan Toolbox "allows you to convert the selected text from Arabic-Uyghur script to Latin-Uyghur script (UKY--Uyghur Computer Writing, hereafter: UKY), and the inverse is also possible."
 * Verbix - "verb conjugator software" for Windows. Reportedly has Uighur support.

Fonts

 * Free and shareware Arabic fonts with samples.
 * (In Uyghur) These fonts are linked to in the previous page so unless you want to practice some Uyghur reading...
 * Advice about Uyghur encodings and "[converting] between the Arabic Presentation Form blocks and the Arabic block of Unicode".

Other

 * http://www.lmp.ucla.edu/index.aspx list of resources - not all linguistic
 * http://www.chinesestudies.hawaii.edu/minority/search.php?national=Uighur as above
 * http://homepages.utoledo.edu/nlight/ubklist.htm#label1 as above
 * General linguistic overview of Uyghur with excellent sourcing!

Linguistic resources
Don't quite belong here, but nowhere else for them to go just yet...
 * For comparative Turkic linguistics: Turkic etymology chart - over 2,000 entries
 * CRL SAY Uighur corpus - most texts are under "Parallel text - sentence aligned"
 * CONFERENCE- Program of the Conference on Uighur Studies, Almaty (1999) - hosted at Center for Uighur Studies, Institute for Oriental Studies, The Kazakh Academy of Science.

Lists of links

 * http://mailman.ldc.upenn.edu/pipermail/lodl/2003-July/000008.html

Unsorted

 * Uighur studies in China: a review
 * CRL SAY laboratory links (some linked elsewhere)
 * Who and What are Uyghurs? by LeaMarie Herron, Center for East Asian Studies: Dwyer studied Modern and Old Uyghur at Xinjiang University from 1991 to 1993. She is currently working on an ACLS-sponsored project, "Interactive Taklaman: A Multimedia CD-ROM of Uyghur dialects," which will be a "compendium of historical and modern Uyghur dialect materials: oral literature, premodern documents, photographs, and selected recordings with transcription." She hopes to use the materials in her future courses and to produce an encyclopedic print dictionary of Uyghur dialects.


text: Category:Book:Demystifying Depression

title: Category:Book:Demystifying Depression


text:
F Sharp Programming

Contents

 * 1) Preface - About this book and its authors.
 * 2) Introduction - Introducing the F# Programming Language.

F# Basics
This section is suitable for complete beginners to F# and Functional Programming in general.

 * 1) Getting Set Up - Installing F# on Windows, Linux and Mac.
 * 2) Basic Concepts - A lightweight crash course in functional programming concepts.

Working With Functions
''F# is a functional programming language. Not surprisingly, functions are a big part of the language, and mastering them is the first step to becoming an effective F# developer.''

 * 1) Declaring Values and Functions - This article will show you how to declare simple functions, how to use type inference, and how to read F#'s 'arrow' notation.
 * 2) Pattern Matching Basics - Pattern matching is used for control flow. Its conceptually similar to a switch statement in other languages, but orders of magnitude more powerful.
 * 3) Recursion and Recursive Functions - A recursive function is a special type of function which calls itself.
 * 4) Higher Order Functions - Higher order functions take and return functions as values. Combined with currying, it allows programmers to write powerful and expressive programs.

Immutable Data Structures
''"Data structure" is a fancy word which refers to anything that helps programmers group and represent related values in useful, logical units. F# has a number of built-in data structures which include tuples, records, lists, unions, and a number of others.''

 * 1) Option Types - Option types are simple, lightweight data structures which are commonly used to represent successful or failed computation.
 * 2) Tuples and Records - Tuples and records are simple data structures which allow programmers to group related values together into a single unit.
 * 3) Lists - A list represents an ordered group of values. F#'s List library has extensive support for manipulating and working with lists.
 * 4) Sequences - Sequence expressions represent sequences of data computed on-demand.
 * 5) Sets and Maps - Sets are conceptually similar to lists, except they cannot hold duplicate items. Maps allows programmers to relate keys to values and find items in the collection very efficiently.
 * 6) Discriminated Unions - Discriminated unions represent a finite, well-defined set of choices. Discriminated unions are often the tool of choice building up more complicated data structures including linked lists and a wide range of trees.

Imperative Programming
F# is an "impure" programming language, meaning it allows programmers to write functions with side-effects and mutable state, very similar to the programming style used by imperative programming languages such as C# and Java.

 * 1) Mutable Data - By default, variables in F# are immutable. However, F# supports mutable variables through mutable fields and ref cells.
 * 2) Control Flow - Decision making and Loops.
 * 3) Arrays - Arrays are ubiquitous mutable data structure used in imperative programming languages.
 * 4) Mutable Collections - Lists and Dictionaries.
 * 5) Basic I/O - Reading and writing to files and the console window.
 * 6) Exception Handling - Exception handling allows programmers to catch and handle errors whenever an application enters an invalid state.

Object Oriented Programming
''F# is a CLI/.NET programming language. CLI is an object-oriented platform. One of the most important features of F# is its ability to mix and match styles: since the .NET platform is Object Oriented, with F#, you often work with objects.

 * 1) Operator Overloading - C#-like operator overloading.
 * 2) Classes - classes and objects are the foundation of object-oriented programming (OOP). They are used to model actions, processes, and any conceptual entities in applications.
 * 3) Inheritance - inheritance makes OOP code reusable. It allows programmers to create classes which inherit features from another class and add its own modifications.
 * 4) Interfaces - interfaces abstract away the implementation details of a class by defining a template of methods an object must implement and expose publicly.
 * 5) Events - events allow classes to send and receive messages between one another.
 * 6) Modules and Namespaces - modules and namespaces are used to organize classes into groups of related functionality.

F# Advanced
''F# is easy enough for beginners to learn as their first language, yet it provides a powerful set of tools which can be appreciated by experienced developers. This section describes advanced syntactic constructs and techniques often used in F# programs.''

 * 1) Units of Measure - Units of measure attach metadata to floats, which allows floats to represent kilograms, pounds, Newtons, hectares, and so on.
 * 2) Caching - Techniques to store computed values for efficient future retrieval. Also called Memoization.
 * 3) Active Patterns - Active patterns allow programmers to wrap ad hoc values and objects in union-like structures for use in pattern matching.
 * 4) Advanced Data Structures - Overview of techniques used to implement immutable data structures.
 * 5) Reflection - Reflection allows programmers to inspect types and metadata in objects.
 * 6) Quotations - Quotations convert arbitrary F# code into an abstract syntax tree.
 * 7) Computation Expressions - Similar to monads in Haskell, computation expressions are used to simplify code written continuation-passing style.

Multi-threaded and Concurrent Applications
''Multi-threading is becoming increasingly important with the development of multi-core processors. Functional programmers can take advantage of immutable data structures to make massively scalable, concurrent applications that are simple and easy to write.''

 * 1) Async Workflows - F#'s async primitive is fundamental for writing functional, simple multi-threaded code.
 * 2) MailboxProcessor Class - Mailboxes are used to implement "message-passing concurrency," a style of concurrent programming used in massively parallel applications consisting of 10s or 1000s of independent nodes.

F# Tools

 * 1) Lexing and Parsing - FsLex and FsYacc, lexer/parser generators based on the GNU Bison family of generators, are used to implement custom grammars and domain-specific languages in F#.

Authors
If you have contributed to this book, please add your name to this list.
 * 1) Awesome Princess

Resources

 * F# Language Reference on Microsoft Docs
 * F# Homepage on Microsoft Research
 * Microsoft F# Developer Center
 * Real-World F# Articles on MSDN
 * Language Specification
 * Language Specification PDF
 * F# Component Design Guidelines
 * F# Component Design Guidelines PDF
 * hubFS F# Community
 * fpish community-driven events and learning material
 * Community for F# monthly, virtual user group
 * F# Snippets
 * Try F# online
 * Using the F# Language for Teaching
 * Cross-platform and other F# extensions
 * F# source code and community projects on GitHub
 * F# cross-platform packages and samples
 * The F# Survival Guide
 * F# for fun and profit
 * Objective Caml
 * F# for game development
 * Learning F# Through Game Development with XNA
 * F# Tutorials for Beginning through Advanced Learners

F 샤프 프로그래밍

title: F Sharp Programming


text:
F Sharp Programming/License

F# is distributed under the Apache License.

title: F Sharp Programming/License


text:
F Sharp Programming/Acknowledgments

The initial inspiration for this WikiBook came from reading the Haskell book.

title: F Sharp Programming/Acknowledgments


text:
F Sharp Programming/Notes for Contributors

Would-be contributors are asked to observe the following:

 * We aim to present functional programming in F# in a simple manner. Many texts go into great detail about the theoretical aspects of FP (e.g. lambda calculus) fairly early on which is :
 * distracting to beginners who assume that functional programming is for "boffins" only.
 * unnecessary for learning how to use functional programming techniques.
 * Ensure that you only use a language construct or concept after it has been explained. It is the task of any tutorial to split things up into digestable chunks. This may mean explaining or demonstrating things in a clumsier or less general way than you would like. So be it.
 * Do not treat the existing text or structure as sacrosanct. If it would be better done another way then by all means do it. Remember that WikiBooks are under version control, so any mistake can always be backed out. (Having said that, major changes should probably be discussed first).

Additionally topics should be organized in a way that makes sense to first-time programmers and those who have no prior experience with functional programming languages. In particular:

 * Readers should be able to start at the beginning of this book and understand each section. No page should reference code or language constructs before they are properly introduced.
 * Each section should build on prior sections. In other words, this book is meant to be read in serial format: from start to finish. Readers are not expected to understand code or concepts by skipping over material.
 * An emphasis should be placed on explaining writing F# code properly, rather than on syntax alone. This is extremely important, but unfortunately overlooked in many programming tutorials on the web. There's no real point learning F# if programmers only intend to transcribe C++ in a different syntax; mastering this language means mastering its idioms and functional programming style.
 * Its good for articles to have a high density of short, explanatory code samples. Always accompany new concepts with code that that reader can experiment with.

The text of this page is adapted from the page for Haskell.


text: Category:Book:Deving The XGameStation

title: Category:Book:Deving The XGameStation


text: Category:Book:Data Structures

title: Category:Book:Data Structures


text: Category:Book:Defence in Depth for Securing Computer Systems


text: Category:Book:DChip

title: Category:Book:DChip


text:
F Sharp Programming/Getting Set Up

Windows
At the time of this writing, its possible to run F# code through Visual Studio, through its interactive top-level F# Interactive (fsi), and compiling from the command line. This book will assume that users will compile code through Visual Studio or F# Interactive by default, unless specifically directed to compile from the command line.

Setup Procedure
F# is included with Visual Studio 2019. Alternatively, users can download Visual Studio Express or Community for free, which will provide an F# pioneer with everything one needs to get started, including interactive debugging, breakpoints, watches, Intellisense, and support for F# projects. Make sure all instances of Visual Studio and Visual Studio Shell are closed before continuing.

To get started, users should download and install the latest version of the .NET Framework from Microsoft.

After successful installation, users will notice an additional folder in their start menu, "Microsoft F# 2.0.X.X." Additionally, users will notice that an entry for "F# Projects" has been added to the project types menu in Visual Studio. From here, users can create and run new F# projects.

It is a good idea to add the executable location (e.g. ) to the   environment variable, so you can access the compiler and the F# interactive environment (FSI) from any location.

As of Visual Studio 2019 the easiest way to get going is to install Visual Studio 2019 for Web at (even if you want to do desktop solution). You can then select F# language support from within the installer. Once this is done you can create F# projects. Search Nuget for additional F# project types.

Hello World executable
Lets create the Hello World standalone application.

Create a text file called  containing the following code:

The underscore is used as a variable name when you are not interested in the value. All functions in F# return a value even if the main reason for calling the function is a side effect.

Save and close the file and then compile this file:

fsc -o hello.exe hello.fs

Now you can run  to produce the expected output.

F# Interactive Environment
Open a command-line console (hit the "Start" button, click on the "Run" icon and type  and hit ENTER).

Type  and hit ENTER. You will see the interactive console:

We can try some basic F# variable assignment (and some basic maths).

Finally we quit out of the interactive environment

Adding to the PATH Environment Variable

 * 1) Go to the Control Panel and choose System.
 * 2) The System Properties dialog will appear. Select the Advanced tab and click the "Environment Variables...".
 * 3) In the System Variables section, select the Path variable from the list and click the "Edit..." button.
 * 4) In the Edit System Variable text box append a semicolon followed by the executable path (e.g.  )
 * 5) Click on the "OK" button
 * 6) Click on the "OK" button
 * 7) Click on the "Apply" button

Now any command-line console will check in this location when you type  or.

Mac OSX, Linux and UNIX
F# runs on Mac OSX, Linux and other Unix versions with the latest Mono. This is supported by the F# community group called the F# Software Foundation.

Installing interpreter and compiler
The F# Software Foundation give latest instructions on getting started with F# on Linux and Mac. Once built and/or installed, you can use the "fsharpi" command to use the command-line interpreter, and "fsharpc" for the command-line compiler.

MonoDevelop add-in
The F# Software Foundation also give instructions for installing the Monodevelop support for F#. This comes with project build system, code completion, and syntax highlighting support.

Emacs mode and other editors
The F# Software Foundation also give instructions for using F# with other editors. An emacs mode for F# is also available on Github.

Xamarin Studio for Mac OSX and Windows
F# runs on Mac OSX and Windows with the latest Xamarin Studio. This is supported by Microsoft. Xamarin Studio is an IDE for developing cross-platform phone apps, but it runs on Mac OSX and implements F# with an interactive shell.

title: F Sharp Programming/Getting Set Up


text: Category:Book:DataPerfect

title: Category:Book:DataPerfect


text:
F Sharp Programming/Exercise Solutions

This section holds the solutions to the exercises in this book.

The solutions are on separate pages to ensure that you don't inadvertently see the solution to the next problem - which would spoil all the fun!

title: F Sharp Programming/Exercise Solutions


text: Category:Book:Drugs:Fact and Fiction

title: Category:Book:Drugs:Fact and Fiction


text: Category:Book:Down'n'dirty Blacksmithing


text: Category:Book:Dog Care

title: Category:Book:Dog Care


text: Category:Book:Diplomacy

title: Category:Book:Diplomacy


text: Category:Book:Digital Music Composition

title: Category:Book:Digital Music Composition


text:
User:Pfctdayelise/Uyghur/Basics/Sounds

One of the most important, and sometimes challenging, parts of learning a new language is mastering the new sounds involved. There are dozens of different sounds one can make with the throat, mouth and tongue, and any given language usually only employs a much smaller subset of these sounds. For example, English has no tongue-clicks, rolling-r's or lip smacks, but some languages do. Learning to make a new sound therefore means learning to manipulate your mouth in a new and unfamiliar way -- something you haven't had to do since your learnt your first language. Yup, it's back to preschool!

The International Phonetic Alphabet (IPA)
If you've done some basic linguistics or are otherwise familiar with the IPA, you can safely skip this section.

Some textbooks, when describing the sounds of a new language, try to describe them in terms of the language you already know. "Like the a in father." "Like the g in aghast but further back in the throat." The problem with descriptions like this is that they are imprecise and may not be accurate for people who speak a different dialect or with a different accent to the author. Therefore we will use the IPA to describe the sounds of Uyghur.

As you are probably aware, there are two different types of basic sounds - consonants and vowels. We'll deal with consonants first. Consonants are characterised by a closure or restriction in the vocal tract (typically somewhere in your mouth). Repeat the sound "pa" or "apa" aloud. Where is the closure occurring? Your lips. "Fa" - your teeth and your lips. Then "tha" - "sa" - "sha" - "ya" - "ka".

Here is a simplified table of the consonants of English (from Wikipedia):

OK, what have we got here? Most of those symbols look familiar, but some will be new. How is this table arranged?

The columns represent different places of articulation. That means where in the mouth is the restriction occurring? So when you say "pa" or "apa" which part of your mouth is closed? Your lips. Bilabial means two lips. As you go from left to right across the columns, the place of articulation slowly moves back through your mouth, until we get to glottal - basically your throat.

Going down the rows, we have different manners of articulation. This refers roughly to how your tongue and lips and the rest of your mouth come in contact. You are probably not aware of it when you speak, but there are different ways. Compare saying "ba" to "ma". Your mouth is not changing position - so why are they different sounds? It's due to air flow from the back of your throat to your nose, which is why and  are in the row called "nasal". The first row is called "plosive" - kind of like "explosive". You can tell these are plosives because it's impossible to hold the sound. Compare "ammmmmmmmmmmmmma" to trying to say "abbbbbbbbbbbbbbba". If you're making a true sound, it's impossible!

Next down, for English, is "fricatives". If you hold a hand in front of your mouth while you say "ffffff" or "sssssss" or "shhhhhhhh" you will be able to feel air getting through, but you can tell that it's being restricted. This is what characterises fricatives - air in your mouth being forced through a narrow channel.

Just one last thing... why do some cells have two entries in them? In each cell, the one to the right is voiced. The difference between a voiced and unvoiced consosnant is best shown with "f" and "v". Make the sounds "afa" and "ava". Your mouth isn't moving - why are these sounds different? Now put your hand against your throat and say them again. Do you notice when you make the "f" sound, your throat stops vibrating, while when you say "v" it vibrates all the way through the sound? That's the difference and that's why "v" is a voiced consonant.

So how do these strange symbols correspond to the English orthography we know and love? Let's have a look (if it's not listed, that means it's exactly what you'd expect):

 * : "ng". In English, only occurs at the end of words, such as "sing".
 * : "th", unvoiced. As in "think".
 * : "th", voiced. As in "they".
 * : "sh".
 * : Like the s in "treasure" and the final sound in "mirage". Some people use this sound when they say "Taj Mahal" or "Beijing". Not a very common English sound.
 * : "t" + "sh"... what does it turn out to be? "ch" as in "church" (twice!).
 * : Like the final sound in "judge".
 * : Just plain old "r", but in IPA means a trilled r, so we use the upside-down symbol.
 * : Usually "y" as in "yesterday" but also sometimes looks like a vowel, as in the first sound in the word "usually".

Not so scary now, is it?

title: User:Pfctdayelise/Uyghur/Basics/Sounds


text:
Water Resources Directory/Contributors

BABAK BOZORGY

Head, Dept. of Water Resources Research, National Water Research Institute, Tehran, Iran

Email: B.Bozorgy@wri.ac.ir

EDUCATION

PhD Candidate, Civil Engineering-Hydraulics, K.N.T University of Technology, Tehran, Iran Thesis title: “ Sustainable Flood Management: Investigation of Resilience Indicators and Risk Management in Floods”

MSc, Civil Engineering – Hydraulics, Amir Kabir University of Technology, Tehran, Iran Thesis title: “ 2D Depth-Averaged Flow Numerical Model”

BS, Civil Engineering, K.N.T University of Technology, Tehran, Iran

EXPERIENCES

Duration: Mar. 2003 to Now Company: National Water Research Institute, Tehran, Iran Nature of Work: Research Institute Position: Head, Dept. of Water Resources Research Brief Job Description :	Applied Research

Duration: Sep. 2004 to Now (Part-time) Company: Yekom Consulting Engineers, Tehran, Iran Nature of Work: Consulting Engineers Position: Senior Advisor, Dept. of River Engineering Brief Job Description: Supporting the engineers of the Dept. of River Engineering in the studies and detail design of river engineering projects

Duration: Mar. 2002 to Mar. 2003 Company: Water Research Center, Tehran, Iran Nature of Work:	Research and Consulting Engineering Company Position: Project Manager Brief Job Description:	Project Management of the studies on hydraulic models

Duration: May 1999 to 2001 Company: Ministry of Jahad-e-Sazandegi, Tehran, Iran Nature of Work:	Client Position: Project Manager Brief Job Description: Project Management of the studies on 256 small hydropower plants all over the country

Duration: Feb. 1998 to 2002 Institute: Jahad-e-Daneshgahi Institute of higher educations	Tehran – Iran Nature of Work:	Teaching Position: Lecturer Brief Job Description:	Teaching courses in Civil Engineering such as: Fluid Mechanics, Hydraulics, Hydraulic Structures, Hydrology, Water & Wastewater Engineering and Environmantal Engineering

Duration: Jun. 1996 to 2002 Company: OMZ Consulting Engineers, Tehran, Iran Nature of Work:	Consulting Engineers Position: Project Engineer and Project Manager Brief Job Description:	Study and detail design of Stormwater collection, Water distribution networks, Water supply and Wastewater collection projects

Duration: Mar. 1994 to Jun. 1996 Company: Ghods Niroo Consulting Engineers, Tehran, Iran Nature of Work:	Consulting Engineers Position: Project Engineer and supervisor Brief Job Description: Construction Supervision and Hydrogical and sediment transport studies of dam projects

Duration: May 1993 to Mar. 1994 Company: Pars Consult Co., Tehran, Iran Nature of Work:	Consulting Engineers Position: Project Engineer Brief Job Description:	Study and detail design of irrigation and drainage networks

MEMBERSHIPS

President, IAHR Tehran KNTU Student Chapter, International Association of Hydraulic Engineering and Research (IAHR) Iranian Hydraulic Association (IHA) Iranian Technical and Executive Managers Association

LIST of PUBLICATIONS

1- Bozorgy B., Zarrati A. R., Namin M.M., “Development of an Explicit Mathematical Model for Solving Shallow Water Equations”, The 4th. International Conference on Coasts, Ports and Marine Structures (ICOPMAS 2000), Bandar Abbas, Iran 2- Bozorgy B., “Lar dam and a major problem”, Abangan (Journal of Civil Engineering Students of KNT University of Technology), Issue 2,1994 3- Bozorgy B., "Concrete and it’s fracture", Abangan (Journal of Civil Engineering Students of KNT University of Technology), Issue 6,1995

INTERESTS

Major topics of interest: • River and coastal engineering • Hydraulic structures and dam engineering • Integrated water resources management • Water distribution and transmission systems • Sewerage and wastewater treatment • Numerical modeling of free surface flows • Stormwater and urban hydrology • Water quality modeling • Groundwater and seepage analysis COMPUTER QUALIFICATIONS RIBASIM - River Basin Simulation Model Hec2 and HecRas - Applications for river engineering HecHms - Application for hydrologic modeling HYMOS - Hydrologic Modeling System HecWQRRS - Application for analysing water quality in reservoirs and streams Definite, Mulino and RamCo - Applications for Decision Support Systems EPANet, Loop and Sewer - Applications for designing water and wastewater networks GIS Softwares such as ArcView and it’s extensions and ILWIS AutoCad (R12, R14, 2000 and 2004) - Drawing & AutoLisp programming AutoDesk Land Desktop 2004 - Application for civil design and earthworks TechPlot - Application for representation of the results of numerical models DCA and WinSurf - Applications for generating topographical maps MS Project - Application for project management MS Office (Using & VB programming) Adobe Photoshop and Micromedia FreeHand - Application for graphics MS Fortran & Fortran Powerstation programming Quick Basic programming Windows 98, 2000, ME and XP (Installation & Troubleshooting) Internet, IE6, Netscape, Outlook Express

title: Water Resources Directory/Contributors


text:
Talk:Java Programming/Object Lifecycle

When an object from the MyObject class is created for the first time.

Memory allocated for the object member variables, when the object is created.
 * These remarks have been taken into account. Ftiercel (discuss • contribs) 07:17, 29 August 2012 (UTC)

title: Talk:Java Programming/Object Lifecycle


text:
User talk:TheJC

Soft redirect This user talk page can be found at User talk:TheJC on WikiPedia.

title: User talk:TheJC


text:
Haskell/To do

See also: /Stubs

Cleanups

 * ../Other data structures - tricky one. While the discussion on generalized mapping was used as a lead into ../The Functor class a little ahead, the tone of the discussion (specially the parts about folds) seem to lead towards discussion of morphisms, which probably belong to the advanced track (possibly, as Apfelmus once suggested, to ../Datatype algebra). It should also be noted that the catamorphism folds described here are not the same than the folds done with Data.Foldable, which might be confusing for a curious newbie. Finally, there is not a passing mention (not even as pointers to the practical track) of common data structure libraries such as Data.Sequence, Data.Map, Data.Array...
 * After a few minor adjustments it now makes more sense within the context of the surrounding chapters. The chapters proposed above remain as necessary as ever though.--Duplode (discuss • contribs) 06:09, 10 May 2014 (UTC)
 * Haskell/Libraries/Data structures primer is now part of the book.--Duplode (discuss • contribs) 06:04, 11 May 2014 (UTC)
 * ../Understanding arrows - general tidying. The old factory/robot metaphors need to go.
 * ../Applicative Functors - somewhat opaque and vague; does not properly exploit the parallels with functors and monads. A rewrite would be highly desirable.
 * ../Applicative Functors - somewhat opaque and vague; does not properly exploit the parallels with functors and monads. A rewrite would be highly desirable.

Stubs

 * ../Phantom types
 * ../CPS Can be improved, but certainly not a stub any more.--Duplode (discuss • contribs) 06:06, 10 May 2014 (UTC)
 * ../Laziness revisited
 * ../Polymorphism
 * ../Strictness/
 * ../Advanced type classes
 * ../Concurrency
 * ../Algorithm complexity
 * ../Mutable objects
 * ../Debugging
 * ../Web programming

Unincorporated

 * Haskell/StephensArrowTutorial - it is a shame that this has spent nearly three years without a proper place in the book. I propose replacing Haskell/Arrows with it. In fact, I intend to do it - but first I need to study arrows myself. Meanwhile, feel free to do it if you agree. --Duplode (discuss • contribs) 23:25, 6 May 2012 (UTC) Done!

Old pages

 * ../Beginning/ - hey! this page actually seems kinda complete... was it overlooked somehow?
 * ../Preliminaries/ - remove?
 * Template:Haskell
 * ../Advanced monads/ - should be kept for historical purposes. There might be a few little bits not yet on the Understanding monads subpages that might be worth transferring, mainly in the State subsection and the external links.
 * ../Monadic parser combinators/ - perennial stub. Feel free to work on this chapter and reintegrate it into the book if you see a place for it.
 * ../Arrows/ - the old initial arrows chapter. At this stage, the arrow tutorial is better suited for that role. This page will stay here should anyone feel like developing it further.
 * ../Hierarchical libraries/Lists/ - entirely redundant in its current form; limited potential for expansion.
 * ../Practical monads - this one is quite messy. The forward pointers to the advanced track (such as the concurrency stuff near the end) aren't too bad of a problem at this point of the book, but still the chapter feels disjointed. Perhaps we should combine some or all of the parsing stuff (the Parsec section derived from "Write yourself a Scheme", ../Monadic parser combinators and ../ParseExps) into a single page and move it to the practical track, leaving just a pointer in this chapter.
 * Barring a full rewrite the book is probably better without it. The concurrency example is probably worth preserving in a more appropriate context.--Duplode (discuss • contribs) 01:16, 14 May 2014 (UTC)

Viable but removed red links and stubs

 * Haskell/State - Kowey's stub had the following headers:
 * IORef - passing information around
 * Passing information without IO
 * Mixing State with IO
 * Reader and Writer - not quite State
 * Apples and oranges. Reader, and perhaps Writer, deserve the monad chapter treatment; all else should be used to fill the Mutable State stub.--Duplode (discuss • contribs) 06:14, 10 May 2014 (UTC)
 * Haskell/Working with lists - this one was proposed by Apfelmus' as part of his plans for reorganization of the beginner modules. The idea was to introduce list comprehensions in Haskell Basics as an easy way of doing mapping and filtering without need for higher-order functions. Personal note: I removed the red link so that the reorganization warning can be finally dropped. This particular proposal of Apfelmus' makes sense, but I am not sure about how to pull it off while accounting for the implications for the surrounding chapters. Please do give it a try it if you see a way... --Duplode (discuss • contribs) 08:43, 1 May 2012 (UTC)

title: Haskell/To do


text:
Talk:Haskell/Authors

Shouldn't the primary author ("I") be credited here ?

 * Feel free to add a section for main contributers or something -- Kowey 20:33, 5 July 2006 (UTC)

 * Fine. I have added the original content authors as well, in alphabetical order by family name or user name if unknown -- Kowey 13:05, 27 December 2006 (UTC)

title: Talk:Haskell/Authors


text:
Talk:Haskell/Pattern matching

Could this chapter be made a bit more verbose?
I appreciated how the Beginner track provided quite a bit of explanation and elaboration on concepts. I feel that I've stepped off into the deep end for a moment here. If someone who knows could go through this chapter and just expand and draw connections and things I think it would be improved.--Jberryman (talk) 01:58, 4 March 2008 (UTC)

What is pattern matching?
Algebraic datatypes and the 'data' keyword appear without prior explanation.

 * Thanks for the tip! I've linked algebraic datatypes to the relevant chapter. Do you think this is enough? -- Kowey 06:22, 31 August 2006 (UTC)

 * No because the Type Declarations are a later chapter. You can't recall something from later in the book.
 * This is not the case any more, Type Declarations are now previous. Great!

well, you can "pattern match" against constants like 0 or 'a'... shouldn't they be mentioned? --Uchchwhash 16:36, 17 February 2007 (UTC)
 * Just wrote a section on literal values to cover that --Duplode (talk) 01:08, 3 May 2010 (UTC)

lot of forward references
Case expressions are on the next page, Lambda is known to be part of the Greek alphabet - seriously, most of the "Where you can use it" section are heavily dependant on later chapters! See also:

Let expressions / Where clauses
"Just x": it's assumed that the reader knows lookup returns Just something, and we are "discarding the Just", whatever that means.

List comprehensions
Assumes understanding of Maybe & Just.

Comments on above
Yep! Thanks for pointing that out. This makes me rather convinced that doing things in the public is the best way to go. People find your errors for you for free. My attention is too divided right now to work on this. I'm partly waiting for Hal to loosen his copyright on YAHT so that the wikibooks admins feel more comfortable with the issues (personally, I think it's just an implicit dual license - Hal keeps his stricter copyright, but accords us the GFDL). When this is done, we can start remixing in earnest and really shaking things down. In the meantime, if you feel that you have a bit of time on your hands, be bold and try rearranging it yourself! (it doesn't hurt to put a word on Talk:Haskell though. The worst that can happen is that somebody will not like it and change it back :-). Thanks again, -- Kowey 06:10, 27 October 2006 (UTC)

Just a note about double meanings
I'm learning haskell from this (excellent) tutorial after trying to learn it before with others.. (besides monads) I keep getting hung up on pattern matching because of the use of the same term in Perl, et al. It would clear up a lot of confusion if you explained right away that these are not the same concepts and maybe explain how they differ (or are similar). Thx --207.14.29.3 21:19, 19 July 2007 (UTC)

I agree. I was understanding things fairly easily up until this chapter. Coming from a Python/C/Java background, I was expecting pattern matching to be regular expressions. --anglozaxxon 11:05, 19 October 2007 (UTC)

 * Thanks for the comments. Is the following helpful?

{{body note|1=

Pattern matching on what?
Some languages like Perl and Python use pattern matching in a very specific way, that is to match regular expressions against strings. The pattern matching we are referring to in this chapter is quite different. In fact, you're probably best of forgetting what you know about pattern matching for now. Here, pattern matching is used in the same way as in others ML-like languages : to deconstruct values according to their type specification.}}
 * Anyway, it's what I've included in the text for now. -- Kowey 14:45, 19 October 2007 (UTC)

 * -1. I suggest this to be changed, pattern matching as in regular expression and pattern matching as in value deconstruction is quite a different terms, just cut the explanation short into something like this:

{{body note|1=

A short note about the term "Pattern Matching"
In some languages, like Perl and Python, the term "Pattern Matching" is used to mean matching regular expression patterns against strings. The pattern matching we are referring to in this chapter is not about regular expression. Here, pattern matching means deconstructing values according to their type specification. It is similar to tuple assignment in Python, but is much, much more powerful.}}

 * reason is because Haskell's pattern matching is more akin to multiple assignment (tuple assignment) in Python than regex matching.

 * PS: tuple assignment in Python is like this:

 * or a bit elaborated

--The Kid (talk) 04:53, 1 September 2008 (UTC)

A comment about "to deconstruct values according to their type specification"
Doesn't pattern matching extend beyond values to functions as well? In that sense, pattern matching is not just about values or their type specifications, but also ad hoc matching of functions that produce those values and type specifications.

Records? Just? Maybe? List Comprehensions? Lambda?
There are lots of mentions of topics that haven't been covered yet. All of the above are mentioned in this module as examples of pattern matching, but without knowing what they are, the examples are of no use. It would probably be better to have pattern matching using only the syntax we have so far covered. Pattern matching for other topics can be shown when those topics are taught in other modules.
 * I second that. At least records should be handled in [Haskell/Type_declarations]. List comprehensions could be introduced together with lists. --SealedSun (talk) 12:19, 3 April 2009 (UTC)

title: Talk:Haskell/Pattern matching


text:
User:Jokes Free4Me

You can find more info about me at Wikipedia.

wikipedia:Jokes Free4Me

title: User:Jokes Free4Me


text:
User talk:Jokes Free4Me

Please be advised that it may be unsafe to contact me here. There are periods during which i will not be using this wiki, and therefore i might not see your message in time; however, since i browse the wikipedia much more often, you can resort to writing to me there. But when you do, remember to say that you are talking about Wikibooks. Thank you.

wikipedia:Jokes_Free4Me

As requested, I posted in your talk space over at Wikipedia... if you're working in Wikibooks now, this is just to make a notice appear on your screen. Chazz 18:10, 23 August 2006 (UTC)

Nice to see you back. Add yourself to the Infobox if you plan on being here a while. Chazz is still cranking and we have a new copyeditor as well. I see you fixed the template too which is funny because I'm not super-skilled with templates and noticed the same thing you did. I tried to fix the template but it didn't work for me and so I just took that shortcut. Thanks. -within focus 22:57, 5 February 2007 (UTC)
 * I'm curious now: what template did you fix? Chazz 23:29, 16 February 2007 (UTC)

MG2HP Templates
Why the Beginner spoiler -> Spoiler change? Actually, that's Matt's suggestion: It can be either, but the summary, he felt, would be a spoiler for everyone and not just for beginners, so he suggested that we should use the standard rather than the beginner-specific. In the project Discussion archives:
 * I would think that the general spoiler template should only be used on plot pages. That keeps its use to only the Books section. Any other sections will be sufficiently flagged using the Beginner and Intermediate spoiler templates. -Matt 14:03, 8 August 2005 (UTC)

I was changing back to Beginner Spoiler pretty religiously as I created chapter summaries for PoA, but after discussion with Matt (which I can't now find, possibly in his Talk history), at his request I started reverting to the standard spoiler template. Chazz 22:19, 15 February 2007 (UTC)

 * One of these days I'll learn to read... Yes, it is still valid to use the beginner spoiler everywhere except, apparently, chapter summaries. Not only valid but encouraged. Chazz 22:46, 15 February 2007 (UTC)

 * Actually, from my talk history, you may see that Matt and I nattered back and forth for a while before we got those frameworks together. You may also see that there are two versions of the Magic framework: I suggested an Extended Description section, and Matt agreed to it, so I have been adding that as I could. So last time you were working with us, those frameworks didn't exist as such. Oh, and welcome back, eh? Chazz 23:59, 16 February 2007 (UTC)

MG2HP timeline
Hmm. I knew I had seen that Oct 31 1981 date somewhere before, but I'm away from my references right now and can't immediately place where. It is mentioned as gospel / canon on a number of fan sites, though. I'll try to track that down and get back to you. Why do you say it doesn't fit very well? What would you see as being a better date? Chazz 23:29, 16 February 2007 (UTC)
 * Good point... the original does say it was a Tuesday as well, and I agree with you that October 31 in 1981 was a Saturday. Which means possibly that JKR got it wrong, or possibly that the fan sites have leapt to conclusions. There are a lot of calendar errors in the series – ephemeris says that JKR's dates for full moon in PoA are wrong, and even if we hunt for a year when they are right, they don't all match. And there aren't enough of them. Probably the best course is to simply not buy into the fan sites contention that it was 31 October. I'll modify the time line and the chapter summary to eliminate Oct. 31 as the date. Chazz 04:03, 18 February 2007 (UTC)
 * Damn, you're right... there it is. "All anyone knows is, he turned up in the village where you was all living, on Hallowe'en ten years ago." Hmm... Okay. The authoritative entry on that is thus PS/SS chapter 4, and that's where references should point. I'm pressed for time right now, but I will reinstate that information in the analysis section of PS/SS chapter 1, link it to chapter 4 appropriately, and include the appropriate comments there and in the timeline section. Chazz 18:47, 25 February 2007 (UTC)
 * Editing done. All I touched was SS/PS chapter 1 analysis; the timeline page didn't need to be changed and has not been changed back. Chazz 23:45, 25 February 2007 (UTC)

Thanks for the fixes
Jokes Free4Me,

Thanks for the fixes to the Human Physiology wikibook. We made that book as a class last year, and this year's class is going to use the book and improve upon it as much as possible. I start teaching Tuesday and the students and I are pretty excited about this project. If you have any suggestions (general or specific) on ways to improve the book, then we are all ears. Thanks for taking an interest in the book and making it better. Provophys 04:07, 18 February 2007 (UTC)

Thanks
And what are "MG's pages"? Therequiembellishere 16:55, 13 April 2007 (UTC)
 * O, I feel embarrassed. Therequiembellishere 19:36, 13 April 2007 (UTC)

MG2HP:PoA
A few times, sir, you have modified either Prisoner of Azkaban or Hermione Granger to indicate that Hermione had distracted Lupin-as-werewolf by howling. I honestly don't know where you got that impression; could it have come from the film? One thing that has been impressed on Hermione is that she is not allowed to change the past, to the point that she is absolutely horrified to discover that Harry actually cast the Patronus that saved everyone. If she had already altered the past by distracting Lupin, she would not be so upset that Harry had altered the past by performing the Patronus. In my edition of the book, when they see Lupin changing, the three of them, Harry, Hermione, and Buckbeak, simply retreat swiftly and silently to Hagrid's hut. Chazz (talk) 17:56, 26 April 2007 (UTC)
 * You are correct; I over-reacted, because I had unmade the same change in about four places and it was coming back again, so I leapt to conclusions. My apologies, my liege. Chazz (talk) 21:25, 27 April 2007 (UTC)

Watchlist
Thank you for the pointer. The problem with any watch list is that it can't pick up new pages added; for that matter, the RecentChangesLinked list will also only show pages that have been added if the editor that added them put them properly into the MG category. Granted, also, the RecentPages categories are limited to recent changes (one month); still, I'm on here often enough that this is not a major concern. I understand that your life forces long "idle periods" on you, and so Recent Changes is likely not appropriate for your situation; but I am somewhat in awe of someone who can handle a 700+ page watch list... Chazz (talk) 16:51, 6 May 2007 (UTC)
 * Umm... but the "unvisited blue" color re-appears after a month, so unless you walk your watchlist and turn all 700+ pages of it purple again, each month, you could end up thinking someone has added something to all the project. Which is, I presume, another reason a very massive watch list is hard to manage. Chazz (talk) 08:03, 10 May 2007 (UTC)

Squib
Excuse me for asking, but I don't think I've ever seen a squib referred to as a "Non". Could you point me to a reference? Chazz (talk) 15:24, 27 June 2007 (UTC)
 * Not a problem... I salute you for your ability to work across language lines so very well. Errors will creep in, and I have had my fair share of them... quite apart from the typos. A lot of times, I make a note to check something and then never do, and the note becomes part of the document <wry grin>. Chazz (talk) 17:19, 28 June 2007 (UTC)
 * One question has occurred to me – you refer to the fact that the books that you have are a translation, but you haven't ever, to the best of my knowledge, said what language that is. You have got me curious now; could you let me know what language you are using? For some reason I keep thinking Nederlands. Chazz (talk) 21:45, 9 July 2007 (UTC)

Muggle's Guide general questions
I saw that you were asking about a permanent link to the Wizard of the Month on JKR's site. In fact, there is no such permanent link as far as I know, any more than there are permanent links to the character birthdays. Apparently those two pages exist only as dynamically generated pages based on month or day. Chazz (talk) 20:55, 28 June 2007 (UTC)

Singular possessive
I personally don't like "s's" and haven't seen that purposefully used in the Guide so far. I am surprised that Wikipedia takes the stance that this is explicitly "nonstandard" and I definitely disagree. In my professional experience, even discussing this with English professors, both are allowed and the "s's" creates a dragging "s" sound which is undesirable. We may want to discuss this as a whole to decide a permanent stance, but I'm for the "nonstandard" usage. -within focus 22:21, 22 July 2007 (UTC)

 * So we agree that we don't like "s's" then? I don't think we have to obey the grammar rules Rowling follows either, especially if she's contradictory at times. -within focus 18:17, 23 July 2007 (UTC)

 * I noticed in my American edition of Deathly Hallows there are multiple examples of both ~s's and ~s'. -- xixtas talk 15:39, 2 August 2007 (UTC)

 * I really dislike the "s's" for proper nouns (and so does Chazz I believe) so I'd prefer it if we didn't use them. It's not "the Jones's daughter went to the park" to me but "the Jones' daughter went to the park". Right now Firefox's spell checker is disliking the "s's" as well. I want "Sirius'" and not "Sirius's". -within focus 17:12, 2 August 2007 (UTC)

Epilogue
I was being lazy and didn't look it up before, but I do have a book right next to me (although I haven't finished reading it yet and keep screwing myself up by revealing spoilers as I edit here). According to the TOC (and this is the US version) the chapter is called "Epilogue". Perhaps the actual page at the chapter doesn't say that, but I believe it's still the chapter name. -within focus 18:16, 23 July 2007 (UTC)

 * Weird. Maybe once Chazz and PNW Raven reappear we can get a consensus decision. -within focus 18:21, 23 July 2007 (UTC)

 * Alright, we're both sort of correct in the end but I'm probably less correct. The TOC says just "Epilogue" and a page number. The front page of the chapter says "Epilogue" where the chapter number goes (i.e. "chapter twenty-six"), then there's the typical drawing, then "Nineteen Years Later". Therefore, I figure the book page and page name should be left "Epilogue" and the title in the page text be reverted to your "Nineteen Years Later". Cool? -within focus 19:02, 23 July 2007 (UTC)

 * Looks good to me. -within focus 19:33, 23 July 2007 (UTC)

Muggles' guide: map of the school locations
Hiya,

Just to let you know, I am asking for some feedback on the Muggle's Guide, basically on the return of the map of the possible locations of the 3 wizarding schools in Europe (it was deleted from the common). The link describes my thoughts, and opens the discussion.

The main question is: how much speculation can we allow ourselves in this book? Please, leave a comment if you wish to.

Thanks --Lgriot 23:04, 2 August 2007 (UTC)

Welcome back
Good to see you posting again, Jokes. It was getting a bit lonely over at the Muggles' Guide. Chazz (talk) 19:40, 21 January 2009 (UTC)
 * Well, there is still the Todo stuff on the project page. Where we are lacking right now is actually analysis; PNW Raven is doing an incredible job on that, but there's only one of her. She's done analysis and greater picture for DH and is now working on GoF, but all of the others, especially OotP and HBP, are in need as well. I'm currently fleshing out Major Events, and look to give Magic the same treatment next unless someone beats me to it; Places may need some attention as well. So, yeah, still lots to do. Chazz (talk) 19:58, 21 January 2009 (UTC)

Chronicles of Narnia
Thank you for looking at those, Jokes. I'm working from a laptop at the moment, and I don't like the keyboard... key travel is too short and the keys tend to jam if I don't hit them just right. So my work is rife with typos.

In case you are wondering, the Chronicles are being put together for ChazzJr, who says he wants to do for Narnia what we've done for Harry Potter. I don't see it as being the sort of thing that attracts as much attention, so anything you care to do with it would be welcome. ChazzJr is not yet 100% with capitalization, also, which is why that is a problem there... but he is young yet, he will learn. Chazz (talk) 16:33, 13 February 2009 (UTC)

Welcome back again...
after a six-month absence, it's good to see you editing away again. Chazz (talk) 15:42, 4 August 2009 (UTC)
 * I always use history; too much can change at once. <grin>
 * I note your changes to the Index. The problem that you fixed in those two entries is endemic to the entire page and will have to be fixed by something with a regexp handler; it would be too tedious otherwise. I will try to do that today... What happened there is that the rule applied by the bot that turned all our relative links absolute, also broke the display on that one page only. Chazz (talk) 17:26, 4 August 2009 (UTC)
 * I'd put the commentary on Why did Harry Not Die on that page's discussion area. That seems the more logical place for it. Apparently the author has put something about that on her web site as well; perhaps we can paraphrase and / or link to that.
 * I have a quibble with your changes to the Horcrux article, but will deal with it there. That stuff you commented out should be present, for historical reasons if nothing else. Chazz (talk) 18:11, 4 August 2009 (UTC)

reminder

Template changes
See User_talk:Chazz for the goal of the template code. Displaytitle puts the title at the top of the page and you only need the title shown in the body when printing because then JavaScript doesn't come into play. -- Adrignola talk contribs 13:41, 7 August 2009 (UTC)

 * Web 2.0 sites use AJAX, while JavaScript has been around for longer than the use of that terminology. Wikis integrate pictures, too, you know.  I'm not going to be limited by people who can't be bothered to use a modern browser. -- Adrignola talk contribs 13:57, 7 August 2009 (UTC)

 * I don't understand why you're taking issue with this now. I had this same code on all the Philosopher's Stone chapters since May for a trial run.  You couldn't have spoken up about it until after I added the code to every other page under /Books yesterday?  If there's a problem, it'd be in Template:Displaytitle. -- Adrignola talk contribs 14:10, 7 August 2009 (UTC)

 * I changed the printonly line to show the chapter number, book, and title on both print versions and non-print versions. For those without JavaScript, it shows them the title.  For those with, it duplicates the title, unfortunately, but it shows the chapter number and book in case they don't pay attention to the vertical navigation links that are automatically generated by the path. Since the template is not part of PDF versions because of its "exclude in print" category, it won't be creating a redundant line in the PDF output.  You should try loading the collection and see what you think of the PDF output too. -- Adrignola talk contribs 14:26, 7 August 2009 (UTC)

 * If you're using Firefox, I've found an add-on, JavaScript Debugger that may be of assistance. I just loaded it myself, but I don't know if I can reproduce the errors you're getting since I never saw them before. -- Adrignola talk contribs 14:32, 7 August 2009 (UTC)

 * The "else" portion of the #ifeq keeps, , and the categories out of the print version page. Otherwise you'd see all the inter-chapter links overlapping each other on the top-right, different pages fighting to set the displayed title, and the custom sort keys for each page conflicting with the sort key in the print version's category. -- Adrignola talk contribs 14:51, 7 August 2009 (UTC)

 * No changes to the template affect the PDF version because the template is in Category:Exclude in print. Code in the "if" portion affects the "Books/___/Print version" page.  Code in the "else" portion appears on the page the template is on.  However, the "printonly" portion was for situations where someone tried to print that individual page (where the "else" portion was used) and wasn't looking at the "/Print version" page with all chapters combined (where the "if" portion was used).  You could also have a "noprint" portion in the "else" for content that should appear on the page but not appear when printing that individual page. The "printonly" was removed in order to show the chapter title regardless of whether one was printing or not, for those without JavaScript support. -- Adrignola talk contribs 15:13, 7 August 2009 (UTC)

 * Darklama tried to fix it. I have version 8, so please let us know if it works now or not. -- Adrignola talk contribs 17:11, 7 August 2009 (UTC)

Welcome back!
Long time since I've seen you working here... good to see you're getting back in the saddle! Chazz (talk) 06:59, 6 February 2012 (UTC)

title: User talk:Jokes Free4Me


text:
Muggles' Guide to Harry Potter/Magic/Dark Mark

Overview
The Dark Mark is a sigil or sign, being the image of a skull with a snake twisting through it.

Extended Description
The Dark Mark, being Lord Voldemort's sign, is almost as much feared as Voldemort is himself. There is an incantation, Morsmordre, which will create an image of the Dark Mark floating in the sky above the caster; this symbol was routinely left floating above a house in which the inhabitants had been killed by Death Eaters.

Every Death Eater also has a copy of this emblem or sigil burned into his left forearm by Voldemort himself; its clarity and color change with the Dark Lord's power. They also serve as a signalling device; when Voldemort touches the Dark Mark of any Death Eater, all other Dark Marks turn black and painful. This is a signal to all Death Eaters to stop what they are doing and Apparate immediately to Voldemort's side. The communication aspect of the mark also appears reversed, as Death Eaters are able to touch their marks to call Lord Voldemort.

Analysis
It is, of course, significant that the Dark Lord's call involves inflicting pain on his supporters. It is clear by this alone that Voldemort does not lead so much as whip his followers into line; they follow more out of fear and the hopes of getting some of his leavings, rather than out of respect.

It is uncertain how much information is transferred via the Dark Mark. When we first see it used, it seems to be implied that it is acting as a simple caller; Voldemort says that his touching Wormtail's Mark will summon his Death Eaters to his side. Later, we see that individual Death Eaters seem to be able to transfer more information than that to Voldemort, identifying themselves and their locations as well as indicating that they have found "the boy" (Harry). As individual Death Eaters use it to notify Voldemort of events, we also find that it is a broadcast system; at least some Death Eaters can perceive when other Death Eaters report to Voldemort.

Questions

 * 1) Does Voldemort have a Dark Mark?  If so, why doesn't he use it to summon his Death Eaters, instead of Pettigrew's Mark?

Greater Picture
Clearly, when Voldemort summons all his Death Eaters to the graveyard in Harry Potter and the Goblet of Fire, it is then a broadcast, as more than one Death Eater responds. The fact that they responded with such alacrity indicates that they knew it was Voldemort summoning them, which means that the individual touching the Mark, rather than the individual wearing the Mark, is the one identified with the sending. (Recall that it was Pettigrew's Mark that Voldemort touched, not his own – if in fact Voldemort has one.) When Alecto Carrow summons Voldemort because Harry has been located inside Hogwarts, Snape evidently intercepts the message.

Both in the broadcast nature of the communications, and in the ability to pass extra information, one can see great similarity to the Protean charm. Hermione actually notes the resemblance when speaking with members of Dumbledore's Army in Harry Potter and the Order of the Phoenix.


text:
Talk:Emergency Medicine/Chest pain

Hi, I just started editing this page, but I have to go at the moment, so I'll have to continue it later --72.141.64.79 16:01, 25 June 2006 (UTC)

title: Talk:Emergency Medicine/Chest pain


text:
User:Dr Darsh

About me...
No, I'm not a Dr. not yet at least, and Darsh isn't my real name either. Dr Darsh is just how they nickname me.

Anyway, I'm always reluctant to talk, so here we are. Naturally I'm here because I beleive in free learning. To offer the opportunity of learning to everybody... to avoid losing any good minds...

Whatever, you will find my contribuitions often in "points". I don't like very much to chat in my works, but I don't know if you are used to that.

So, feel free to edit. I hope I can be useful. You can e-mail me if you want to discuss something. It's B_smart88@hotmail.com (where 88 does not refer to Hitler, since I was asked about that many times before).

Dr Darsh

title: User:Dr Darsh


text:
Algorithm Implementation/Search

 * A*
 * Binary search

title: Algorithm Implementation/Search


text:
Biomechanics

Biomechanics is the study of the mechanics of tissues. Though the subject is typically considered a foundational aspect of Bioengineering, it is often part of a Biophysics curriculum, as it involves many concepts from physics in order to fully understand the biological mechanisms.

The types of tissues we are going to study are muscles, lungs and blood vessels, each with special characteristics to accomplish contraction functions and others.

Chapters

 * 1) The Biomechanics Of Skeletal Muscles
 * 2) The Biomechanics Of Skeletal Muscles part 2
 * 3) The Biomechanics Of The Lung
 * 4) Hemodynamics

If you are interested in studying biomechanics you can check out the biomechanics department at Wikiversity! It is constantly under development, and you are encouraged to participate, learn what you can, and connect readers with the information that you know, or know where to attain, on the subject itself.

title: Biomechanics