Xinyue's Recipes
- Add the yeast to the appropriate amount of warm water and mix well, add the yeast water and oil to the flour. Add 220 grams of water in portions and stir with chopsticks while adding. Until there is no dry powder, it is flocculent.
- Knead into a smooth dough, cover with plastic wrap, and ferment at room temperature for about 40 minutes. The fermented dough was taken out, kneaded, and divided into small pieces. I made 16 buns for this little bun skin.
- Stuffing method: chopped half-fat lean meat, I directly use a blender to stir. Add 100 grams of water to the minced meat three times. Stir until the meat has completely absorbed the water. Add light soy sauce, cooking wine, oyster sauce and bean paste and stir well.
- Put a small piece of oil paper under the wrapped buns, put them in a steamer, and let them wake up for 15 minutes. After the water is boiled, steam for 15 minutes. After turning off the heat, wait 3-5 minutes before opening the lid.
- Steam for 20 minutes.
- Chop pork into stuffing, add soy sauce, refined salt and mix well, then add pepper noodles, lard, add water and stir in one direction until it is evenly mixed, wash and chop the vegetables, squeeze the water, and place in the meat stuffing Add monosodium glutamate, green onion, minced ginger, and sesame oil, mix well to form a filling.
- Put the fine powder on the chopping board and scald it with boiling water, mix it into a snowflake shape, knead it into a dough, knead it evenly and knead it into a long strip, lay it down into 50 doses, sprinkle some dry noodles, flatten it, and roll it into a round thin crust.
- Hold the skin in your left hand, smear the stuffing in your right hand, and then use your hand to align the edges of the dumpling skin and knead it together from right to left to make a crescent-shaped dumpling.
- Steam them for about 10 minutes.
- Prepare some forzen dumplings.
- Put a small amount of oil in the pan (as long as it spreads evenly on the bottom of the pan), turn on the heat.
- Place the dumplings in the pot (do not need to defrost, put them directly).
- Fry on medium heat for a minute or two, until you hear a sizzling sound, the bottom of the dumplings starts to turn golden brown.
- At this time, pour half a bowl of water, the amount of water is about one-third of the dumplings.Cover the lid and cook on medium heat for about five minutes.
- Taking advantage of this gap, use flour and water to make a thin flour and water at a ratio of about 1:10.
When there is a sizzling noise in the pot, it is getting louder and louder. At this time, the water in the pot is almost dry. Open the lid and pour the diluted flour and water evenly into the pot (if you want to sprinkle sesame and green onion, sprinkle it at this time Into), turn to low heat and fry until the water in the pan is dry, the flour and water will form a crisp film on the bottom of the pan, then turn off the fire.
- Done!


{% extends '_layouts/layout_3-3.html' %} {% block page_title %}{{serviceName}}{% endblock %} {% block pageTitle %}{% endblock %} {% block content %}
The application will be contacted by a member of...TBC. From this, it is decided if the applicant's service fits the criteria for being a 'local service' and is therefore eligable to be listed on the library. If yes, then an email is sent to applicant using the email address given in the first email. They click a link and are directed to the following screen...
Service information form {% endblock %} {% block footer %}{% endblock %}


Select country to infect
Feel free to nest models within models.
Create the following nested structure:
dis -> pop -> geo
Assume you have picked USA and you want to map level 2. Add the following graphs:
pop/geo should have:
dis/pop should have:
Please add at least one model first.
Attach the disease to your model dis.
Once you click Generate Scenario there is no going back. Please make sure that you have filled out all fields and setup your models correctly, including linking them to graphs as well as disease and infector.
After you click Generate Scenario, all the necessary scenario files will be created on the server and properly linked. You can access all created scenarios and load them by clicking on Load Scenario at any given time.


{{doctor.name}}'s Medico
Home
(current)
Appointments
Create
See all Appointments
Details
Personal Details
Work Details
Prescriptions
Create A New Prescription
Search for An Old Prescription
Reports
Set Slots
OTP
Chat
Reciepts
Logout
Change Password
{% csrf_token %}
Search
{% block content %} {% endblock %}


First iOS application made, for creating animated GIF on iPhone. Using Objective-c, and AVFoundation framework.
Source: remirobert/gif-creator-ios


Index
see vṛh
The relations of the two roots bṛh, and the connection of some of their derivatives, are not wholly clear.


Of course! Bring me the materials I need and I'll make anything you want at once!
What do you want?
Examine the list


Welcome to the Spring WebMVC Example Application. This application provides a REST API for a very basic calculator. The following paths are supported for GET requests:
All of these paths return a JSON object containing the supplied parameters and the result. For example, this service call returns:
{ "operation": "add", "left": 2, "right": 2, "result": 4 }In addition, for illustration purposes, the service supports POST requests for:
The request body must be a JSON object similar to the above ("result" is of course optional). The response will be JSON as above.


- 2.1 线程管理的基础 Basic Thread Mangement
- 2.2 向线程函数传递参数 Passing arguments to a thread function
- 2.3 Transferring ownership of a thread 转移线程所有权
- 2.4 运行时决定线程数量
- 2.5 识别线程 Identifying
2.1 线程管理的基础 Basic Thread Mangement
每个程序至少有一个线程：执行main()函数的线程，其余线程有其各自的入口函数. 线程与原始线程(以main()为入口函数的线程)同时运行。如同main()函数执行完会退出一样，当线程执行完入口函数后，线程也会退出. 在为一个线程创建了一个 std::thread 对象后，需要等待这个线程结束。
Every C++ program has at least one thread, which is started by the C++ runtime: the thread running main(). Your program can then launch additional threads that have another function as the entry point. These threads then run concurrently with each other and with the initial thread. Just as the program exits when the program returns from main(), when the specified entry point function returns, the thread exits. As you’ll see, if you have a std::thread object for a thread, you can wait for it to finish。
2.1.1 Launching a thread 启动线程
使用C++线程库启动线程，可以归结为构造 std::thread 对象:
Starting a thread using the C++ Thread Library always boils down to constructing a std::thread object:
class background_task
{
public:
void operator()() const
{
do_something();
do_something_else();
}
};
background_task f;
std::thread my_thread(f);
有件事需要注意，当把函数对象传入到线程构造函数中时，如果你传递了一个临时变量，而不是一个命名的变量；C++编译器会将其解析为函数声明，而不是类型对象的定义。
One thing to consider when passing a function object to the thread constructor is to avoid what is dubbed “C++’s most vexing parse.” If you pass a temporary rather Basic thread management 17 than a named variable, then the syntax can be the same as that of a function declaration, in which case the compiler interprets it as such, rather than an object definition.
For example,
std::thread my_thread(background_task());
这里相当与声明了一个名为my_thread的函数，这个函数带有一个参数(函数指针指向没有参 数并返回background_task对象的函数)，返回一个 std::thread 对象的函数，而非启动了一个线程。 declares a function my_thread that takes a single parameter (of type pointer to a function taking no parameters and returning a background_task object) and returns a std::thread object, rather than launching a new thread.
使用在前面命名函数对象的方式，或使用多组括号①，或使用新统一的初始化语法②，可以避免这个问题。 You can avoid this by naming your function object as shown previously, by using an extra set of parentheses, or by using the new uniform initialization syntax, for example:
// 1
std::thread my_thread((background_task()));
// 2
std::thread my_thread{background_task()};
// 3
std::thread my_thread([]{
do_something();
do_something_else();
});
启动了线程，你需要明确是要等待线程结束，还是让其自主运行。如果 std::thread 对象销毁之前还没有做出决定，程序就会终止( std::thread 的析构函数会调用 std::terminate() )。因此，即便是有异常存在，也需要确保线程能够正确的加入(joined)或分离(detached).
It’s therefore imperative that you ensure that the thread is correctly joined or detached, even in the presence of exceptions。
如果不等待线程，就必须保证线程结束之前，可访问的数据得有效性。
If you don’t wait for your thread to finish, then you need to ensure that the data accessed by the thread is valid until the thread has finished with it.
//函数已经结束，线程依旧访问局部变量
//A function that returns while a thread still has access to local variables
struct func
{
int& i;
func(int& i_) : i(i_) {}
void operator() ()
{
for (unsigned j=0 ; j<1000000 ; ++j)
{
// 1. 潜在访问隐患：悬空引用 Potential access to dangling reference
do_something(i);
}
}
};
void oops()
{
int some_local_state=0;
func my_func(some_local_state);
std::thread my_thread(my_func);
// 2. 不等待线程结束 do not wait for thread to finish
my_thread.detach();
} // 3. 函数退出时新线程可能还在运行 New thread might still be running when func exits
处理这种情况的常规方法 ：
common way to handle this scenario
1 数据复制到线程中，而非共享数据
make the thread function self-contained and copy the data into the thread rather than sharing the data。
2 使用一个能访问局部变量的函数去创建线程是一个糟糕的主意(除非十分确定线程会在函数完成前结束，例如使用join)。
ensure that the thread has completed execution before the function exits by joining with the thread.
2.1.2 等待线程完成 Waiting for a thread to complete
join()是简单粗暴的等待线程完成或不等待。当你需要对等待中的线程有更灵活的控制时，比
如，看一下某个线程是否结束，或者只等待一段时间(超过时间就判定为超时)。想要做到这
些，你需要使用其他机制来完成，比如条件变量和期待(futures).
If you need more fine-grained control over waiting for a thread, such as to
check whether a thread is finished, or to wait only a certain period of time, then you
have to use alternative mechanisms such as condition variables and futures。
调用join()的行为，还清理了线程相关的存储部分，这样 std::thread 对象将不再与已经
完成的线程有任何关联。这意味着，只能对一个线程使用一次join();一旦已经使用过
join()， std::thread 对象就不能再次加入了，当对其使用joinable()时，将返回否（false）。
The act of calling join() also cleans up any storage associated
with the thread, so the std::thread object is no longer associated with the nowfinished
thread; it isn’t associated with any thread. This means that you can call
join() only once for a given thread; once you’ve called join(), the std::thread
object is no longer joinable, and joinable() will return false.
<IP_ADDRESS> 特殊情况下的等待 Waiting in exceptional circumstances
如前所述，需要对一个还未销毁的 std::thread 对象使用join()或detach()。如果想要分离一
个线程，可以在线程启动后，直接使用detach()进行分离。如果打算等待对应线程，则需要细
心挑选调用join()的位置。当在线程运行之后产生异常，在join()调用之前抛出，就意味着很这
次调用会被跳过.
you need to ensure that you’ve called either join() or detach() before a std::thread object is destroyed. If you’re detaching a thread, you can usually call detach() immediately after the thread has been started, so this isn’t a
problem. But if you’re intending to wait for the thread, you need to pick carefully the place in the code where you call join(). This means that the call to join() is liable to be skipped if an exception is thrown after the thread has been started but before the call to join().
struct func;
void f()
{
int some_local_state=0;
func my_func(some_local_state);
std::thread t(my_func);
try
{
do_something_in_current_thread();
}
catch(...)
{
t.join(); // 1
throw;
}
t.join(); // 2
}
// Using RAII to wait for a thread to complete
class thread_guard
{
std::thread& t;
public:
explicit thread_guard(std::thread& t_):
t(t_){}
~thread_guard()
{
if(t.joinable())
{
t.join();
}
}
thread_guard(thread_guard const&)=delete;
thread_guard& operator=(thread_guard const&)=delete;
};
struct func;
void f()
{
int some_local_state=0;
func my_func(some_local_state);
std::thread t(my_func);
thread_guard g(t);
do_something_in_current_thread();
}
2.1.3 后台运行线程 Running threads in the background
如果线程分离，那么就不可能有 std::thread 对象能引用它，分离线程
的确在后台运行，所以分离线程不能被加入. C++运行库保证，当线程退出时，
相关资源的能够正确回收，后台线程的归属和控制C++运行库都会处理.
if a thread becomes detached, it isn’t possible to obtain a
std::thread object that references it, so it can no longer be joined. Detached threads
truly run in the background; ownership and control are passed over to the C++ Runtime
Library, which ensures that the resources associated with the thread are correctly
reclaimed when the thread exits.
这种线程的特点就是长时间运行；线程的生命周期可能会从某一个应用起始到结束，可能会在后台监视文件系统，还有可能对缓存进行清理，亦或对数据结构进行优化.
Such threads are typically long-running; they may well run for almost the entire lifetime of
the application, performing a background task such as monitoring the filesystem,
clearing unused entries out of object caches, or optimizing data structures.
如果不是后台线程，但是若能确定该线程什么时候结束，或者是”发后即忘”(fire andforget)的任务的也可以使用detached线程。 At the other extreme, it may make sense to use a detached thread where there’s another mechanism for identifying when the thread has completed or where the thread is used for a “fire and forget” task.
void edit_document(std::string const& filename)
{
open_document_and_display_gui(filename);
while(!done_editing())
{
user_command cmd=get_user_input();
if(cmd.type==open_new_document)
{
std::string const new_name=get_filename_from_user();
std::thread t(edit_document,new_name); // 1
t.detach(); // 2
}
else
{
process_user_input(cmd);
}
}
}
2.2 向线程函数传递参数 Passing arguments to a thread function
需要注意的是，默认参数要拷贝到线程独立内存中，即使参数是引用的形式。
it’s important to bear in mind that by default the arguments are copied into internal
storage, where they can be accessed by the newly created thread of execution,
even if the corresponding parameter in the function is expecting a reference。
void f(int i, std::string const& s);
std::thread t(f, 3, "hello");
代码创建了一个调用f(3, “hello”)的线程。注意，函数f需要一个 std::string 对象作为第二个
参数，但这里使用的是字符串的字面值，也就是 char const * 类型。之后，在线程的上下文
中完成字面值向 std::string 对象的转化。需要特别要注意，当指向动态变量的指针作为参数
传递给线程的情况，代码如下：
This creates a new thread of execution associated with t, which calls f(3,”hello”).
Note that even though f takes a std::string as the second parameter, the string literal
is passed as a char const* and converted to a std::string only in the context of
the new thread. This is particularly important when the argument supplied is a
pointer to an automatic variable, as follows:
void f(int i,std::string const& s);
void oops(int some_param)
{
char buffer[1024]; // 1
sprintf(buffer, "%i",some_param);
std::thread t(f,3,buffer); // 2
t.detach();
}
这种情况下，buffer②是一个指针变量，指向本地变量，通过std::thread对象构造函数copy到thread内部成员中②。然而，函数有很大的可能，会在thread将字面值转化成 std::string 对象之前崩溃(oops)，从而导致线程的一些未定义行为。解决方案就是将字面值转化为 std::string 对象，然后传递给thread，从而拷贝buffer到thread中去.
In this case, it’s the pointer to the local variable buffer B that’s passed through to the
new thread c, and there’s a significant chance that the function oops will exit before
the buffer has been converted to a std::string on the new thread, thus leading to
undefined behavior. The solution is to cast to std::string before passing the buffer
to the std::thread constructor.
void f(int i,std::string const& s);
void not_oops(int some_param)
{
char buffer[1024];
sprintf(buffer,"%i",some_param);
// 使用std::string，避免悬垂指针 Using std::string avoids dangling pointer
std::thread t(f,3,std::string(buffer));
// poesudo code in constructor of thread
// std::string internal_str = std::string(buffer); // value-copy
t.detach();
}
不过，也有相反的情况：你想要的就是引用拷贝 而非默认的值拷贝，你需要更新你传递的引用，例如：
It’s also possible to get the reverse scenario: the object is copied, and what you
wanted was a reference. This might happen if the thread is updating a data structure
that’s passed in by reference, for example:
void update_data_for_widget(widget_id w,widget_data& data); // 1
void oops_again(widget_id w)
{
widget_data data;
std::thread t(update_data_for_widget,w,data); // 2
display_status();
t.join();
process_widget_data(data); // 3
}
当线程调用
update_data_for_widget函数时，传递给函数的参数是data变量内部拷贝的引用，而非数据本
身的引用。因此，当线程结束时，内部拷贝数据将会在数据更新阶段被销毁，且 process_widget_data将会接收到没有修改的data变量③。
使用 std::bind ，就可以解决这个问题，使用 std::ref 将参数转换成引用的形式。这种情况下，可将线程的调用，改成以下形式：
Consequently, when the
thread finishes, these updates will be discarded as the internal copies of the supplied arguments are destroyed, and process_widget_data will be passed an unchanged data d rather than a correctly updated version. you need to wrap the arguments that really need to be references in std::ref. In this case, if you change the thread invocation to：
std::thread t(update_data_for_widget,w,std::ref(data));
2.3 Transferring ownership of a thread 转移线程所有权
假设要写一个函数，该函数会创建一个运行在后台的新线程， 并且会返回该线程的所有权给函数调用者；
或完全与之相反：创建一个线程，并将所有权通过参数传递给另外一个函数，并且在该函数作用域内join该线程。
总之，新线程的所有权都需要转移。 明执行线程的所有权可以在 std::thread 实例中移动，下面将展示一个例
子。例子中，创建了两个执行线程，并且在 std::thread 实例之间(t1,t2和t3)转移所有权：
the ownership of a particular thread of execution can be moved between std::thread instances, as in the following example. The example 26 CHAPTER 2 Managing threads shows the creation of two threads of execution and the transfer of ownership of those threads among three std::thread instances, t1, t2, and t3:
void some_function();
void some_other_function();
/* 1 a new thread is started and associated with t1. */
std::thread t1(some_function);
/* 2
* ownership is then transferred over to t2 when t2 is constructed,
* by invoking std::move() to explicitly move ownership.
* At this point, t1 no longer has an associated thread of execution;
* the thread running some_function is now associated with t2.
*/
std::thread t2=std::move(t1);
/* 3
* Then, a new thread is started and associated with a temporary std::thread
* object d. The subsequent transfer of ownership into t1 doesn’t require a call to std::
* move() to explicitly move ownership, because the owner is a temporary object—moving
* from temporaries is automatic and implicit.
*/
t1=std::thread(some_other_function);
/* 4
* t3 is default constructed e, which means that it’s created without any associated
* thread of execution. Ownership of the thread currently associated with t2 is transferred
* into t3 f, again with an explicit call to std::move(), because t2 is a named object. After
* all these moves, t1 is associated with the thread running some_other_function, t2 has no
* associated thread, and t3 is associated with the thread running some_function.
*/
std::thread t3;
t3=std::move(t2);
/* 5
* The final move g transfers ownership of the thread running some_function back
* to t1 where it started. But in this case t1 already had an associated thread (which was
* running some_other_function), so std::terminate() is called to terminate the
* program. This is done for consistency with the std::thread destructor. You saw in
* section 2.1.1 that you must explicitly wait for a thread to complete or detach it before
* destruction, and the same applies to assignment: you can’t just “drop” a thread by
* assigning a new value to the std::thread object that manages it.
*/
t1=std::move(t3); // 赋值操作将使程序崩溃 This assignment will terminate program!
The move support in std::thread means that ownership can readily be transferred out of a function:
// 函数返回 std::thread 对象 Returning a std::thread from a function
std::thread f()
{
void some_function();
return std::thread(some_function);
}
std::thread g()
{
void some_other_function(int);
std::thread t(some_other_function,42);
return t;
}
Likewise, if ownership should be transferred into a function, it can just accept an instance of std::thread by value as one of the parameters, as shown here:
// 传递 std::thread 对象到函数 pass in a std::thread to a function
void f(std::thread t);
void g()
{
void some_function();
// tempory thread instance and use std::move implicitely
f(std::thread(some_function));
std::thread t(some_function);
// named thread instance t and so has to use std::move explicitely
f(std::move(t));
}
class scoped_thread
{
std::thread t;
public:
explicit scoped_thread(std::thread t_): // 1
t(std::move(t_))
{
if(!t.joinable()) // 2
throw std::logic_error(“No thread”);
}
~scoped_thread()
{
t.join(); // 3
}
scoped_thread(scoped_thread const&)=delete;
scoped_thread& operator=(scoped_thread const&)=delete;
};
struct func;
void f()
{
int some_local_state;
scoped_thread t(std::thread(func(some_local_state))); // 4
do_something_in_current_thread();
}
std::thread 对象的容器，如果这个容器是移动敏感的(比如，标准中的 std::vector<> )，那么移动操作同样适用于这些容器.
The move support in std::thread also allows for containers of std::thread objects, if those containers are move aware (like the updated std::vector<>).
void do_work(unsigned id);
void f()
{
std::vector<std::thread> threads;
for(unsigned i=0; i < 20; ++i)
{
threads.push_back(std::thread(do_work,i)); // 产生线程 spawn threads
}
std::for_each(threads.begin(),threads.end(),
std::mem_fn(&std::thread::join)); // 对每个线程调用join() call join on each thread
}
2.4 运行时决定线程数量
将 std::thread 放入 std::vector 是向线程自动化管理迈出的第一步：并非为这些线程创建独
立的变量，并且将他们直接加入，可以把它们当做一个组。创建一组线程(数量在运行时确定)，可使得这一步迈的更大.
Putting std::thread objects in a std::vector is a step toward automating the management of those threads. You can take this a step further by creating a dynamic number of threads determined at runtime.
template<typename Iterator,typename T>
struct accumulate_block
{
void operator()(Iterator first,Iterator last,T& result)
{
result=std::accumulate(first,last,result);
}
};
template<typename Iterator,typename T>
T parallel_accumulate(Iterator first,Iterator last,T init)
{
unsigned long const length=std::distance(first,last);
if(!length) // 1
return init;
unsigned long const min_per_thread=25;
unsigned long const max_threads=
(length+min_per_thread-1)/min_per_thread; // 2
unsigned long const hardware_threads=
std::thread::hardware_concurrency();
unsigned long const num_threads= // 3
std::min(hardware_threads != 0 ? hardware_threads : 2, max_threads);
unsigned long const block_size=length/num_threads; // 4
std::vector<T> results(num_threads);
std::vector<std::thread> threads(num_threads-1); // 5
Iterator block_start=first;
for(unsigned long i=0; i < (num_threads-1); ++i)
{
Iterator block_end=block_start;
std::advance(block_end,block_size); // 6
threads[i]=std::thread( // 7
accumulate_block<Iterator,T>(),
block_start,block_end,std::ref(results[i]));
block_start=block_end; // 8
}
accumulate_block<Iterator,T>()(
block_start,last,results[num_threads-1]); // 9
std::for_each(threads.begin(),threads.end(),
std::mem_fn(&std::thread::join)); // 10
return std::accumulate(results.begin(),results.end(),init); // 11
}
2.5 识别线程 Identifying
First, the identifier for a thread can be obtained from its associated std::thread object by calling the get_id() member function. returns a defaultconstructed std::thread::id object, which indicates “no any thread.”.
线程标识类型是 std::thread::id ，可以通过两种方式进行检索。第一种，可以通过调用 std::thread 对象的成员函数 get_id() 来直接获取。如果 std::thread 对象没有与任何执行线程相关联， get_id() 将返回 std::thread::type 默认构造值，这个值表示“没有线程”。第二种，当前线程中调用 std::this_thread::get_id().
threadsstd::thread::id 类型对象提供相当丰富的对比操作；比如，提供为不同的值进行排序. 标准库也提供 std::hash
std::thread::id master_thread;
void some_core_part_of_algorithm()
{
if(std::this_thread::get_id()==master_thread)
{
do_master_thread_work();
}
do_common_work();
}
std::thread::id 可以作为一个线程的通用标识符，当标识符只与语义相关(比如，数组的索
引)时，就需要想其他办法了（例如之前例子中只用循环中的index作为线程的标识）。
The idea is that std::thread::id will suffice as a generic identifier for a thread in
most circumstances; it’s only if the identifier has semantic meaning associated with it
(such as being an index into an array) that alternatives should be necessary.


9 items to bring with you to freshman year:
Quarter jar for laundry
Bring a stash of quarters for laundry. Over the summer, keep every quarter you get from change from gas stations, local coffee shops and restaurants.  Having to do your own laundry and pay for it every time may be a bit of a hassle, but having change set aside for the washers and dryers every week will make your life a lot easier when washing your clothes.
Planner
Invest in a calendar planner for your first year of college. Keeping a personal planner is a great way to stay organized and on top of your assignments. While balancing multiple classes on different days, you’ll want a place to keep your assignments and due dates all in one place. You can even make it fun by including stamps and stickers to customize the planner to your liking.
Comfy shoes for walking to class
To some people this may seem like a no brainer, but to others it might be the thing you wish you hadn’t forgotten the most. Bring a pair of comfy shoes to walk around campus in. Not all of your trips to the dining hall and class will be a long walk, but over a couple of days without supportive shoes your feet might begin to hurt. You’ll be grateful you packed comfortable shoes when you’re walking up Morton Hill to your 9:00 a.m. class.
Reusable water bottle
When gathering up items around your house to bring to college, don’t forget your water bottle. By bringing your own water, you’ll be amazed how much money you save from buying water and sports drinks from the vending machine. You’ll also be saving the earth by limiting yourself on disposable water bottles.
Headphones
You are not going to want to forget these. Make sure to pack at least one set of earbuds/headphones. They will come in handy when you are dying to listen to music in between classes, need an upbeat boost at the gym or just want some background music playing when working on assignments. Nobody likes when people listen to music out loud in public, so bring a set of earbuds.
Journal
Freshman year is going to be a transition, so what better way to keep track of how you’re feeling than by journaling? Bring a brand new journal with you when you move in. It is a great idea to journal during adjustment moments in life. It will be a great way to document how you’re feeling, the memories you are making and the people you are meeting.
Easy to grab snacks
Whether you’ve overslept or need a snack on the way to class, easy to grab snacks can be a life saver. Stock your dorm room with fruit cups, granola bars, fruit snacks, individual bags of chips and other easy to pack items to ensure you won’t be hungry during your breaks between meals. You’ll be thankful for these the next time you audibly hear someone else’s stomach growling during a lecture.
Lanyard
Since most freshmen on campus don’t have their cars with them, a lanyard to hold their keys is often overlooked when packing. However, this could be one of the most important things you bring. By packing a lanyard or wrist keychain, you will be able to keep your keys on you at all times without accidentally locking yourself out of your dorm. Nobody wants to get locked out and have to pay a fee for getting your RA to let you into your room.
Extra masks
Don’t forget to pack multiple masks for your freshman year (other than the one you are wearing to move in). It is a smart idea to keep a spare or two in your backpack and gym bag for those mornings when you realize you accidentally left the dorm without one. Also, by having multiple masks you won’t have to clean them each as often since you will have many to rotate throughout the week.


Get Result for a Partition in Sequential Modular Analysis Use-Case.Description:Gets results for a specified partition after a Full Sequential Modular Analysis computation.Assumptions:None.Exceptions:None.


Class DocumentCreationInfo
Class DocumentCreationInfo
- Echosign\RequestBuilders\Agreement\DocumentCreationInfo implements Echosign\Interfaces\RequestBuilder
Namespace: Echosign\RequestBuilders\Agreement
Package: Echosign\RequestBuilders\Agreement
Located at RequestBuilders/Agreement/DocumentCreationInfo.php
Package: Echosign\RequestBuilders\Agreement
Located at RequestBuilders/Agreement/DocumentCreationInfo.php
public
|
#
__construct(
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
#
addRecipient( null $role, null $email = null, null $fax = null )
You must specify email OR fax, but not both. An exception is thrown if you try to add a recipient with both email and fax. this is a restriction from adobe. |
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
|
|
public
mixed
|
|
public
|
|
public
array
|
string |
SIGN_ESIGN
|
#
'ESIGN'
|
string |
SIGN_WRITTEN
|
#
'WRITTEN'
|
string |
FLOW_NOT_REQUIRED
|
#
'SENDER_SIGNATURE_NOT_REQUIRED'
|
string |
FLOW_SIGNS_LAST
|
#
'SENDER_SIGNS_LAST'
|
string |
FLOW_SIGNS_FIRST
|
#
'SENDER_SIGNS_FIRST'
|
string |
SEQUENTIAL
|
#
'SEQUENTIAL'
|
string |
PARALLEL
|
#
'PARALLEL'
|
protected
string
|
$signatureType
['ESIGN' or 'WRITTEN']: |
#
'ESIGN'
|
public
|
$callbackinfo
|
|
public
|
$daysUntilSigningDeadline
|
|
public
string
|
$locale
|
#
'en_US'
|
protected
string
|
$signatureFlow
SENDER_SIGNATURE_NOT_REQUIRED, SENDER_SIGNS_LAST, or SENDER_SIGNS_FIRST |
|
public
|
$message
|
|
protected
|
$reminderFrequency
|
|
protected
|
$name
|
|
protected
array
|
$formFieldLayerTemplates
|
#
[ ]
|
protected
|
$securityOptions
|
|
protected
array
|
$recipients
|
#
[ ]
|
protected
array
|
$ccs
|
#
[ ]
|
protected
|
$vaultingInfo
|
|
protected
array
|
$mergeFieldInfo
|
#
[ ]
|
protected
array
|
$fileInfos
|
#
[ ]
|
protected
|
$postSignOptions
|


Featured Film
Each week, we feature a classic film and have an accompanying movie screeing and Blu-Ray special. This week is "A Streetcar Named Desire".
Products
Checkout
Your cart
-
$12
Casablanca
A hollywood classic starring Humphrey Bogart and Ingred Bergman. DVD format. -
$8
Singing in the Rain
A family favorite musical starring. DVD format. -
$5
Ben Hur
The quintisential sword and sandal film. Blu-Ray format. -
Promo code
- Total (USD) $20


Version 1.2.0
- Improve UI
- Remove thumbnails of deleted videos
- Improve performance by releases an existing object URL after used
Version 1.1.0
- Add video thumbnail
- Subtitle height and font size can now be adjusted
- Double-Click Arrow Left/Right to rewind/fast-forward for 30 second
- Add Shortcut Keys to toggle subtitle visibility, control subtitle height and subtitle font size
- Goto Help & Support page to read about new shortcut key guide


I currently work on a feature where you can compare 2 weapons on a weapon detail page.
It shows you the advantages of each weapon.
BrainFooLong
Administrator
Is now included via fast weapon switch. Its a better a simpler way for me.
Topicstarter
Guest
Its a simpler was for you, i understand that. But i dont think that is better.
A extra window where you can see the stats of each weapon would be very nice.
You also could make the advantages colored (better= blue and worse = red or somthing)
Greetz and keep up the very very very good work!!!
We love you all <3 ^^
BrainFooLong
Administrator
Ya, i think it exists always a better way :-)
I have a huge todo list for the next months and there are also more weapon info improvements.
So just keep tracked for news, enough things comming in the future :-)
Greetz
Topicstarter
Guest
I just came here to request this exact thing :)
Would be really good idea to be able to compare chosen 2 weapons in weapon detail page. A lot easier if you can see the both 2 weapon stats in the same page right next to each other, possibly having the better / worse parts highlighted with blue & red.
BrainFooLong
Administrator
You will get in the next update a highly detailed weapon table with all weapon information for all weapons, sortable and markable for compare.


Байрлах хоног: 5
2016-11-29 2016-12-04
Stay in the heart of Ulaanbaatar – Show map One of our top picks in Ulaanbaatar. Offering an indoor pool and a spa and wellness centre, The Corporate Hotel and Convention Centre is located in Ulaanbaatar. Free Wi-Fi access is available. Each room here will provide you with a TV, air conditioning and a hot tub. Featuring a shower, private bathroom also comes with a bath and a hairdryer. Extras include a minibar and a seating area. At The Corporate Hotel and Convention Centre you will find a restaurant and a fitness centre. Others offered at the property include meeting facilities, luggage storage and an ironing service. The property offers free parking. The Corporate Hotel and Convention Centre is a 10-minute walk from National Stadium and a 20-minute walk from National Park. Ulaanbaatar International Airport is about 40 minutes' drive away. The on-site Chairman Restaurant serves authentic local food. We speak your language! The Corporate Hotel and Convention Centre has been welcoming Booking.com guests since 14 Jul 2014. Hotel Rooms: 94
<EMAIL_ADDRESS>+976 70111407
Mahatma Gandhi street-39, 212513 Ulaanbaatar, Mongolia
Featuring magnificent views of the Nayramdal Park or Great Chinggis Khaan Square, this room comes with a flat-screen satellite television and a coffee/tea maker. Separate shower and bathtub are provided in the heated bathroom.
This spacious suite has a separate bedroom and living room, equipped with a flat-screen satellite television and a coffee/tea maker. The heated bathroom is fitted with separate shower and bath. Magnificent views of the Nayramdal Park or Great Chinggis Khaan Square can be enjoyed from the room window.
Offering magnificent views of the Nayramdal Park or Great Chinggis Khaan Square, this room is equipped with a flat-screen satellite TV and a coffee/tea maker. There are separate shower and bath with heated flooring in the bathroom.
Та нууц үгээ мартсан уу? Та манай сайтанд бүртгүүлсэн бүртгэлтэй имэйл хаягаа оруулна уу!


Bases: object
Returns a constant.
Bases: nova.api.openstack.xmlutil.Selector
Returns the empty string if Selector would return None.
Bases: nova.api.openstack.xmlutil.Template
Represent a master template.
Master templates are versioned derivatives of templates that additionally allow slave templates to be attached. Slave templates allow modification of the serialized result without directly changing the master.
Attach one or more slave templates.
Attaches one or more slave templates to the master template. Slave templates must have a root element with the same tag as the master template. The slave template’s apply() method will be called to determine if the slave should be applied to this master; if it returns False, that slave will be skipped. (This allows filtering of slaves based on the version of the master template.)
Return a copy of this master template.
Bases: object
Selects datum to operate on from an object.
Bases: nova.api.openstack.xmlutil.Template
Represent a slave template.
Slave templates are versioned derivatives of templates. Each slave has a minimum version and optional maximum version of the master template to which they can be attached.
Hook method for determining slave applicability.
An overridable hook method used to determine if this template is applicable as a slave to a given master template. This version requires the master template to have a version number between min_vers and max_vers.
| Parameters: | master – The master template to test. |
|---|
Create a template element as a child of another.
Corresponds to the etree.SubElement interface. Parameters are as for TemplateElement, with the addition of the parent.
Bases: object
Represent a template.
Hook method for determining slave applicability.
An overridable hook method used to determine if this template is applicable as a slave to a given master template.
| Parameters: | master – The master template to test. |
|---|
Create a tree.
Serializes an object against the template. Returns an Element node with appropriate children.
| Parameters: | obj – The object to serialize. |
|---|
Serialize an object.
Serializes an object against the template. Returns a string with the serialized XML. Positional and keyword arguments are passed to etree.tostring().
| Parameters: | obj – The object to serialize. |
|---|
Return string representation of the template tree.
Returns a representation of the template as a string, suitable for inclusion in debug logs.
Unwraps a template to return a template element.
Wraps a template element to return a template.
Bases: object
Template builder.
This class exists to allow templates to be lazily built without having to build them each time they are needed. It must be subclassed, and the subclass must implement the construct() method, which must return a Template (or subclass) instance. The constructor will always return the template returned by construct(), or, if it has a copy() method, a copy of that template.
Construct a template.
Called to construct a template instance, which it must return. Only called once.
Bases: object
Represent an element in the template.
Append a child to the element.
Apply text and attributes to an etree.Element.
Applies the text and attribute instructions in the template element to an etree.Element instance.
| Parameters: |
|
|---|
Append children to the element.
Get an attribute.
Returns a callable which performs datum selection.
| Parameters: | key – The name of the attribute to get. |
|---|
Insert a child element at the given index.
Return the attribute names and values.
Return the attribute names.
Remove a child element.
Render an object.
Renders an object against this template node. Returns a list of two-item tuples, where the first item is an etree.Element instance and the second item is the datum associated with that instance.
| Parameters: |
|
|---|
Set an attribute.
| Parameters: |
|
|---|
Template element text.
Either None or a callable taking an object and optional boolean do_raise indicator and returning the datum bound to the text of the template element.
Return string representation of the template tree.
Returns a representation of the template rooted at this element as a string, suitable for inclusion in debug logs.
Unwraps a template to return a template element.
Hook method.
An overridable hook method to determine whether this template element will be rendered at all. By default, returns False (inhibiting rendering) if the datum is None.
| Parameters: | datum – The datum associated with this template element. |
|---|
Wraps a template element to return a template.
Get items in obj.
Utility for simple XML templates that traditionally used XMLDictSerializer with no metadata. Returns a template element where the top-level element has the given tag name, and where sub-elements have tag names derived from the object’s keys and text derived from the object’s values. This only works for flat dictionary objects, not dictionaries containing nested lists or dictionaries.
Attach an Atom <links> element to the parent.


STealth
Dashboard
Game
Let's play together
0
Object
Your browser does not support the HTML5 canvas tag.
Would you use this board for this project?
Yes
No


I came down from my 4th, and strongest experience with salvia around 15 minutes ago. I used roughly 1/10th of a gram of 10x extract. Beforehand, I left from my house to the nearby woods and found a comfy spot near a patch of flowers beside a small brook. I sat down, and inhaled all of the smoke in one long hit and held it for around 25 seconds.
The Experience:
As I exhaled, I laid down, staring at the bright blue sky, framed on all sides by treetops. Suddenly, the world seemed to turn upside-down. The sky wasn't above me anymore, it was right in front of me, the trees made a tunnel that I walked through towards it. It was as if the trees were knocked over, laid on thier sides. I felt like I could have walked up one of them if I wanted. I was floating. At this point I tried fruitlessly to maintain a grip on reality, as I turned my head from side to side, I realized that I was in a completely foreign world, I felt like I could never go back, like it would be that way forever. I continued trying to reach the sky with no avail.
I closed my eyes, then opened them and noted that there was absolutley no difference. It was then that the world began to fold in on itself. The whole universe was two diagonal lines, crossing each others path, morphing and folding over where they intersected, and I was right in the middle of this grand spectacle. I was connected to one of the lines, bending and changing with it. This faded away and I began to percieve reality again.
I clumsily sat up and looked at the ground. There were vauge faces on all the blades of grass, forming a sort of pathway towards a nearby flower bed. They beconed me to follow them, and I felt extremely compelled to do so. I started to crawl along the path, until I put my hand down on a dead branch from a rose bush. I picked it up, but I couldn't comprehend what it was, it was utterly foreign. It was like all objects weren't connected to language, like I was an infant looking at it for the very first time. I was sitting there, playing with it and poking the thorns, when I suddenly realized what it was. I threw it down and examined my hand, which appeared to be free of injury.
After this minor setback I continued towards the yellow flowers. They were smiling at me. I touched one of the flowers, then suddenly I pulled up and picked the flower from the stem. As I was pulling it seemed like the flower was screaming in agony, I wanted to stop but it was too late. The remaining stem was in its last throws of death, moaning and twitching. I didn't actually hear it, but I knew it was happening. I looked down at the flower in my hand, on the verge of tears. I felt terrible, like a murderer. I whispered to the flower 'I'll take care of you... I promise I'll take care of you.'
I looked up at the sky. The branches of the tree were blowing in the wind, but the sections of sky around them were somehow connected, and were moving too. By this point I was coming down. I stood up and was very, very off balance. I wandered back through the woods, twoards my house, flower still in hand. Nature was beautiful, the grass seemed greener, the sky brighter. I felt very connected to nature, and felt love for everything and everyone around me. I stopped near a small brook and watched the water flow for a few minutes before returning to my house, feeling refreshed and at peace. I set the flower in a small vase with some water, feeling relieved that I had carried out my promise. The flower is sitting beside me right now.
Retrospective:
All in all, it was a beautiful experience, one of my best salvia trips so far. I wouldn't say any part of the experience was scary, or tense. Being in the woods was a great enhancer for the trip, and I'll make sure to do it again.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Pyclaw Utility Module¶
pyclaw.util¶
Pyclaw utility methods
- class pyclaw.util.FrameCounter¶
Simple frame counter
Simple frame counter to keep track of current frame number. This can also be used to keep multiple runs frames seperated by having multiple counters at once.
Initializes to 0
- get_counter()¶
Get the current frame number
- increment()¶
Increment the counter by one
- reset_counter()¶
Reset the counter to 0
- set_counter(new_frame_num)¶
Set the counter to new_frame_num
- pyclaw.util.add_parent_doc(parent)¶
add parent documentation for a class
- pyclaw.util.check_diff(expected, test, **kwargs)¶
Checks the difference between expected and test values, return None if ok
This function expects either the keyword argument ‘abstol’ or ‘reltol’.
- pyclaw.util.compile_library(source_list, module_name, interface_functions=, []local_path='./', library_path='./', f2py_flags='', FC=None, FFLAGS=None, recompile=False, clean=False)¶
Compiles and wraps fortran source into a callable module in python.
This function uses f2py to create an interface from python to the fortran sources in source_list. The source_list can either be a list of names of source files in which case compile_library will search for the file in local_path and then in library_path. If a path is given, the file will be checked to see if it exists, if not it will look for the file in the above resolution order. If any source file is not found, an IOException is raised.
The list interface_functions allows the user to specify which fortran functions are actually available to python. The interface functions are assumed to be in the file with their name, i.e. claw1 is located in ‘claw1.f95’ or ‘claw1.f’.
The interface from fortran may be different than the original function call in fortran so the user should make sure to check the automatically created doc string for the fortran module for proper use.
Source files will not be recompiled if they have not been changed.
One set of options of note is for enabling OpenMP, it requires the usual fortran flags but the OpenMP library also must be compiled in, this is done with the flag -lgomp. The call to compile_library would then be:
compile_library(src,module_name,f2py_flags=’-lgomp’,FFLAGS=’-fopenmp’)
For complete optimization use:
FFLAGS=’-O3 -fopenmp -funroll-loops -finline-functions -fdefault-real-8’
Input: - source_list - (list of strings) List of source files, if these are just names of the source files, i.e. ‘bc1.f’ then they will be searched for in the default source resolution order, if an explicit path is given, i.e. ‘./bc1.f’, then the function will use that source if it can find it.
- module_name - (string) Name of the resulting module
- interface_functions - (list of strings) List of function names to provide access to, if empty, all functions are accessible to python. Defaults to [].
- local_path - (string) The base path for source resolution, defaults to ‘./’.
- library_path - (string) The library path for source resolution, defaults to ‘./’.
- f2py_flags - (string) f2py flags to be passed
- FC - (string) Override the environment variable FC and use it to compile, note that this does not replace the compiler that f2py uses, only the object file compilation (functions that do not have interfaces)
- FFLAGS - (string) Override the environment variable FFLAGS and pass them to the fortran compiler
- recompile - (bool) Force recompilation of the library, defaults to False
- clean - (bool) Force a clean build of all source files
- pyclaw.util.construct_function_handle(path, function_name=None)¶
Constructs a function handle from the file at path.
This function will attempt to construct a function handle from the python file at path.
Input: - path - (string) Path to the file containing the function
- function_name - (string) Name of the function defined in the file that the handle will point to. Defaults to the same name as the file without the extension.
Output: - (func) Function handle to the constructed function, None if this has failed.
- pyclaw.util.convert_fort_double_to_float(number)¶
Converts a fortran format double to a float
Converts a fortran format double to a python float.
number: is a string representation of the double. Number should be of the form “1.0d0”
- pyclaw.util.gen_variants(application, verifier, kernel_languages=('Fortran', ), **kwargs)¶
Generator of runnable variants of a test application given a verifier
Given an application, a script for verifying its output, and a list of kernel languages to try, generates all possible variants of the application to try by taking a product of the available kernel_languages and (petclaw/pyclaw). For many applications, this will generate 4 variants: the product of the two main kernel languages (‘Fortran’ and ‘Python’), against the the two parallel modes (petclaw and pyclaw).
For more information on how the verifier function should be implemented, see util.test_app for a description, and util.check_diff for an example.
All unrecognized keyword arguments are passed through to the application.
- pyclaw.util.read_data_line(inputfile, num_entries=1, data_type=<type 'float'>)¶
Read data a single line from an input file
Reads one line from an input file and returns an array of values
inputfile: a file pointer to an open file object num_entries: number of entries that should be read, defaults to only 1 type: Type of the values to be read in, they all must be the same type
This function will return either a single value or an array of values depending on if num_entries > 1
- pyclaw.util.run_app_from_main(application, setplot=None)¶
Runs an application from pyclaw/examples/, automatically parsing command line keyword arguments (key=value) as parameters to the application, with positional arguments being passed to PETSc (if it is enabled).
Perhaps we should take the PETSc approach of having a database of PyClaw options that can be queried for options on specific objects within the PyClaw runtime instead of front-loading everything through the application main...
- pyclaw.util.run_serialized(fun)¶
Decorates a function to only run serially, even if called in parallel.
In a parallel communicator, the first process will run while the remaining processes block on a barrier. In a serial run, the function will be called directly.
This currently assumes the global communicator is PETSc.COMM_WORLD, but is easily generalized.
- pyclaw.util.test_app(application, verifier, kwargs)¶
Test the output of a given application against its verifier method.
This function performs the following two function calls:
output = application(**kwargs) check_values = verifier(output)
The verifier method should return None if the output is correct, otherwise it should return an indexed sequence of three items:
0 - expected value 1 - test value 2 - string describing the tolerance type (abs/rel) and value.
This information is used to present descriptive help if an error is detected. For an example verifier method, see util.check_diff


PlugRailsCookieSessionStore (plug_rails_cookie_session_store v2.0.0)
Stores the session in a cookie.
This cookie store is based on Plug.Crypto.MessageVerifier
and Plug.Crypto.Message.Encryptor
which encrypts and signs
each cookie to ensure they can't be read nor tampered with.
Since this store uses crypto features, it requires you to
set the :secret_key_base
field in your connection. This
can be easily achieved with a plug:
plug :put_secret_key_base
def put_secret_key_base(conn, _) do
put_in conn.secret_key_base, "-- LONG STRING WITH AT LEAST 64 BYTES --"
end
Options
:encrypt
- specify whether to encrypt cookies, defaults to true. When this option is false, the cookie is still signed, meaning it can't be tempered with but its contents can be read;:encryption_salt
- a salt used withconn.secret_key_base
to generate a key for encrypting/decrypting a cookie;:signing_salt
- a salt used withconn.secret_key_base
to generate a key for signing/verifying a cookie;:key_iterations
- option passed toPlug.Crypto.KeyGenerator
when generating the encryption and signing keys. Defaults to 1000;:key_length
- option passed toPlug.Crypto.KeyGenerator
when generating the encryption and signing keys. Defaults to 32;:key_digest
- option passed toPlug.Crypto.KeyGenerator
when generating the encryption and signing keys. Defaults to:sha256
;:serializer
- cookie serializer module that definesencode/1
anddecode/1
returning an{:ok, value}
tuple. Defaults to:external_term_format
.
Examples
# Use the session plug with the table name
plug Plug.Session, store: PlugRailsCookieSessionStore,
key: "_my_app_session",
encryption_salt: "cookie store encryption salt",
signing_salt: "cookie store signing salt",
key_length: 64,
serializer: Poison
Link to this section Summary
Functions
Callback implementation for Plug.Session.Store.delete/3
.
Callback implementation for Plug.Session.Store.get/3
.
Callback implementation for Plug.Session.Store.init/1
.
Callback implementation for Plug.Session.Store.put/4
.
Link to this section Functions
delete(conn, sid, opts)
Callback implementation for Plug.Session.Store.delete/3
.
get(conn, cookie, opts)
Callback implementation for Plug.Session.Store.get/3
.
init(opts)
Callback implementation for Plug.Session.Store.init/1
.
put(conn, sid, term, opts)
Callback implementation for Plug.Session.Store.put/4
.


Back
Buttons
Text Button
Refresh Button
Disabled Button
The disabled button will not fire click events.


I am a Full Stack Web Developer and former IT Business Development Manager with experience in Javascript, JQuery, HTML5, CSS3, Node.js, Express, MySQL, Sequelize, AJAX, Bootstrap 3/4, MongoDB, Data Visualization. I have managed many IT projects with a high level focus on requirements gathering, planning and client satisfaction.
I really love what I do, and it is this passion that allows me to deliver the best version of myself in all my projects. I do not quit until I am completely satisfied with what I have done. Take a look at some of my Projects
The front end of a website is your first impression. Getting this right is of utmost importance. My experience in front-end technologies such as HTML, CSS, JavaScipt, and jQuery, along with my knowledge of different CSS Frameworks, such as Bootstrap and Materialize and additionally my knowledge in many JavaScript frameworks such as Node, Angular, and React prepares me to deliver beautiful looking websites .
The backend is where all the heavy lifting is done. All successful websites have very organized and efficient back ends. My experience in MySQL, MongoDB, Express, Sequelize and Data Visualization provide me with the skill set to develop highly customized, yet effective back end databases.
I have a passion for web development. I truly love what I do. I make sure that each one of my assignments portrays the best of me. I believe that perfection is not attainable, but to chase after it will bring me closer to my best. In this pursuit, I have created many projects which I am proud of. Please take some time to review my projects and feel free to visit my Git Hub and go through my repositories.


Make strokes on this canvas. Right-click the canvas to recognize. If a misrecognition occurs, add the mis- recognized gesture as an example of the intended gesture.


Parsers, Formatters, Validators and Errors
The data in the model should be in a format appropriate for computing rather than being formatted for display (think dollar signs, commas etc). This means it needs to be translated as it is marshalled back and forth between the model and the DOM. To that end BINDster provides:
- Parsers - code that will parse data in form fields into a suitable format, throwing an error when the format is incorrect. BINDster will never transfer the data to the model unless the parser is happy with it. Use the b:parse="js code" on any form field that contains a b:bind. By convention the "js code" is simply a call to a method in the controller which is in scope when the js is executed (e.g. parseDate())
- Validator - code that process the data after it is parsed to determine whether it is correct or not.
It can throw an error if the data is incorrect. Use the b:validate="js code" on any form field that contains a b:bind. The "js code" is usually one or more calls to validators methods in the controller (e.g. isBetween(0, 50);isMinimumLength(8))
- Error Binding - The b:binderror attribute binds an element to an error string that is specific to that binding. The error string is set as part of the validator or parser throwing an error.
- Message Tags - The b:message tag maps a message code and data parameters to an error string such that the code in validators and formatters need not be language dependent.
- Formatters - code that will format data before it is transferred to the DOM. To invoke the formatter use b:format="js code" on any element that contains a b:bind. The "js code" is usually a method that will return the formatted value to be transferred to the element (e.g. c.formatDate())
Parsers
Parsers should do the following:
- Expect the value directly from the form field in the controller's value property (e.g. this.value)
- Translate the value as needed and return it
- Throw an error object as does a paraser.if the value cannot be parsed. The object should contain these properties::
- message which is either an error message or the name of a b:message which defines an error message
- Any other properties that will be used by the b:message tag to format the error message
- Anything that the controller needs to do by way of setting state to indicate that an error condition exists.
Here is an example of a parser:
Validators
Validators are similar to parsers but generally are not expected to have to parse the values. The validators are called after the parser and may also throw an error object. They do not need to return a value.
Here is an example of a validator:
Message Tags
A special tag that allows the text of errors to be defined directly in the view to keep text out of the controller. This makes multi-lingual applications easier to manage since only the view need be modified. They are defined as:
<message name="error name" value="error message"></message>
or if you don't want to use namespaces

The "error name" is a name that is referred to by the parser or validator when they throw an error. It is the message property of the object that they throw. The "error name" is the error string and may include {property references} within curly braces that inject values from other properties that are in the object being thrown by a parser or validator. Here is an example
Error Binding
It is customary to place an error message in view, often next to the field that is in error. BINDster has two attributes that help with this:
- The b:binderror="bind property" attribute which will bind an element to any error generated for the property being bound to.
- The b:binderrordata="extra data" attribute which when used with b:binderror="bind property" let's you specify additional properties that may be injected in the b:message tag
Here is a complete example:
Formatters
Formatters should do the following:
- Expect the the value to be formatted in the controller's value property.
- Format the data as needed and return the formatted value
Here is an example of a formatter:


HEARTS IN ATLANTIS RATING: 5/10
For more reviews and movie trailers, visit http://www.joblo.com/
PLOT: A strange old man comes to live in a small town with secrets from the past. He befriends a young boy whose mom is extremely selfish, and offers him advice on love, life and girls. But where does this man come from? What's with all the mystery? Does this movie have any real point? Find out below...
CRITIQUE: A movie which obviously means well, but doesn't really provide the needed "oomph" to back up its mysterious build-up. Not the kind of movie that you should watch when you're sleepy, that's fer sure (unless you wanna fall asleep, of course). It moves at a slow pace, gives you hints of stuff here and there, clues behind some of its vagueness but ultimately very little to sustain its well-established ominous potential. You wait, you wait, you wait...and watch Anthony Hopkins and Anton Yelchin develop an interesting relationship throughout, watch as exquisite shots of nostalgia and youth pass before your eyes, but there's always something telling you that there's gotta be more behind all of this, a hint of spirituality, a lining of depth, a greater love or something, but ultimately...well, it just never comes. The ending is too "ho-hum" and doesn't give you anything more than what it is, which is basically just a...coming-of-age story? I hoped that this movie would hit me emotionally, hoped that it would have me wondering aloud, hoped that I might recognize something in it, which I had never seen in any other movie before, but this film just didn't provide any of that.
Basically, it was a disappointment. Sure, some of its elements were spot-on. Hopkins was rock solid as the mystery man, the little boy was perfect and delivered the goods in both his happy and sad moments, as did Mika Boorem as Carol, his "girlfriend" in the day. The cinematography and the innocence of the time were also captured idealistically and damn, if that wasn't one of the grooviest soundtracks of the year (very Sinatra-esque). But the bottom line with most films is their story and this one just didn't deliver. It also featured a very one-dimensional mother character, whom we try to understand, but are given no reasons to appreciate in any way. We also get an explanation as to Hopkins' character at some point in the film, but when all is said and done, it doesn't really seem to be that relevant to the picture as a whole. I mean, whether or not he is what he is, has little to do with the major drive of the film, so why build so much into it in the first place? I don't know, I guess what I'm saying is that I don't think the director did a good job of balancing the different elements here, and had my focus going one way, when really the film wasn't so much about that, then it was something else (I'm trying not to spoil anything here, so bear with my babbling).
Of course, I'm more than willing to admit that perhaps I didn't "get" the undertones in this movie, or that there was some kind of "deeper meaning" behind it all, but the bottom line with the film is that it just didn't bring anything new to the table, especially when placed against much greater and comparable films like STAND BY ME (which was also based on a Stephen King story). Then again, I didn't care for THE GREEN MILE either, and most folks seemed to like that, so being in the same vein as that flick, you might want to check this one out just the same, if you enjoyed the latter. Overall, this film provides for solid acting, a fun soundtrack and wonderful atmosphere, but very little of resonance or freshness.
 Well, other than the fact that it reminds me of that mediocre Disney flick from this summer, it's apparently something to do with youth and love, but I challenge you to decipher that one when the film is done. It's a game in itself.
Where's JoBlo coming from? The Dead Zone (8/10) - The Gift (7/10) - The Green Mile (4/10) - Meet Joe Black (6/10) - Shawshank Redemption (9/10) - The Sixth Sense (8/10) - Stand by Me (8/10) - Unbreakable (9/10)
Review Date: September 20, 2001 Director: Scott Hicks Writer: William Goldman Producer: Kerry Heysen Actors: Anthony Hopkins as Ted Brautigan Anton Yelchin as Bobby Garfield Hope Davis as Elizabeth Garfield Genre: Drama Year of Release: 2001 ------------------------------------ JoBlo's Movie Emporium http://www.joblo.com/ ------------------------------------ (c) 2001 Berge Garabedian
========== X-RAMR-ID: 29531 X-Language: en X-RT-ReviewID: 250781 X-RT-TitleID: 1110107 X-RT-SourceID: 573 X-RT-AuthorID: 1021 X-RT-RatingText: 5/10
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Dynamic update is the term used for the ability under certain specified conditions to add, modify or delete records or RRsets in the master zone files. Dynamic update is fully described in RFC 2136.
Dynamic update is enabled on a zone-by-zone basis, by including an allow-update or update-policy clause in the zone statement.
Updating of secure zones (zones using DNSSEC) follows RFC 3007: SIG and NXT records affected by updates are automatically regenerated by the server using an online zone key. Update authorization is based on transaction signatures and an explicit server policy.
All changes made to a zone using dynamic update are stored in the zone's journal file. This file is automatically created by the server when when the first dynamic update takes place. The name of the journal file is formed by appending the extension .jnl to the name of the corresponding zone file. The journal file is in a binary format and should not be edited manually.
The server will also occasionally write ("dump") the complete contents of the updated zone to its zone file. This is not done immediately after each dynamic update, because that would be too slow when a large zone is updated frequently. Instead, the dump is delayed by 15 minutes, allowing additional updates to take place.
When a server is restarted after a shutdown or crash, it will replay the journal file to incorporate into the zone any updates that took place after the last zone dump.
Changes that result from incoming incremental zone transfers are also journalled in a similar way.
The zone files of dynamic zones cannot normally be edited by hand because they are not guaranteed to contain the most recent dynamic changes - those are only in the journal file. The only way to ensure that the zone file of a dynamic zone is up to date is to run rndc stop.
If you have to make changes to a dynamic zone manually, the following procedure will work: Shut down the server using rndc stop (sending a signal or using rndc halt is not sufficient). Wait for the server to exit, then remove the zone's .jnl file, edit the zone file, and restart the server. Removing the .jnl file is necessary because the manual edits will not be present in the journal, rendering it inconsistent with the contents of the zone file.
The incremental zone transfer (IXFR) protocol is a way for slave servers to transfer only changed data, instead of having to transfer the entire zone. The IXFR protocol is documented in RFC 1995. See Proposed Standards.
When acting as a master, BIND 9 supports IXFR for those zones where the necessary change history information is available. These include master zones maintained by dynamic update and slave zones whose data was obtained by IXFR, but not manually maintained master zones nor slave zones obtained by performing a full zone transfer (AXFR).
When acting as a slave, BIND 9 will attempt to use IXFR unless it is explicitly disabled. For more information about disabling IXFR, see the description of the request-ixfr clause of the server statement.
Setting up different views, or visibility, of DNS space to internal and external resolvers is usually referred to as a Split DNS setup. There are several reasons an organization would want to set up its DNS this way.
One common reason for setting up a DNS system this way is to hide "internal" DNS information from "external" clients on the Internet. There is some debate as to whether or not this is actually useful. Internal DNS information leaks out in many ways (via email headers, for example) and most savvy "attackers" can find the information they need using other means.
Another common reason for setting up a Split DNS system is to allow internal networks that are behind filters or in RFC 1918 space (reserved IP space, as documented in RFC 1918) to resolve DNS on the Internet. Split DNS can also be used to allow mail from outside back in to the internal network.
Here is an example of a split DNS setup:
Let's say a company named Example, Inc. (example.com) has several corporate sites that have an internal network with reserved Internet Protocol (IP) space and an external demilitarized zone (DMZ), or "outside" section of a network, that is available to the public.
Example, Inc. wants its internal clients to be able to resolve external hostnames and to exchange mail with people on the outside. The company also wants its internal resolvers to have access to certain internal-only zones that are not available at all outside of the internal network.
In order to accomplish this, the company will set up two sets of nameservers. One set will be on the inside network (in the reserved IP space) and the other set will be on bastion hosts, which are "proxy" hosts that can talk to both sides of its network, in the DMZ.
The internal servers will be configured to forward all queries, except queries for site1.internal, site2.internal, site1.example.com, and site2.example.com, to the servers in the DMZ. These internal servers will have complete sets of information for site1.example.com, site2.example.com, site1.internal, and site2.internal.
To protect the site1.internal and site2.internal domains, the internal nameservers must be configured to disallow all queries to these domains from any external hosts, including the bastion hosts.
The external servers, which are on the bastion hosts, will be configured to serve the "public" version of the site1 and site2.example.com zones. This could include things such as the host records for public servers (www.example.com and ftp.example.com), and mail exchange (MX) records (a.mx.example.com and b.mx.example.com).
In addition, the public site1 and site2.example.com zones should have special MX records that contain wildcard (`*') records pointing to the bastion hosts. This is needed because external mail servers do not have any other way of looking up how to deliver mail to those internal hosts. With the wildcard records, the mail will be delivered to the bastion host, which can then forward it on to internal hosts.
Here's an example of a wildcard MX record:
* IN MX 10 external1.example.com.
Now that they accept mail on behalf of anything in the internal network, the bastion hosts will need to know how to deliver mail to internal hosts. In order for this to work properly, the resolvers on the bastion hosts will need to be configured to point to the internal nameservers for DNS resolution.
Queries for internal hostnames will be answered by the internal servers, and queries for external hostnames will be forwarded back out to the DNS servers on the bastion hosts.
In order for all this to work properly, internal clients will need to be configured to query only the internal nameservers for DNS queries. This could also be enforced via selective filtering on the network.
If everything has been set properly, Example, Inc.'s internal clients will now be able to:
Look up any hostnames in the site1 and site2.example.com zones.
Look up any hostnames in the site1.internal and site2.internal domains.
Look up any hostnames on the Internet.
Exchange mail with internal AND external people.
Hosts on the Internet will be able to:
Look up any hostnames in the site1 and site2.example.com zones.
Exchange mail with anyone in the site1 and site2.example.com zones.
Here is an example configuration for the setup we just described above. Note that this is only configuration information; for information on how to configure your zone files, see Section 3.1
Internal DNS server config:
acl internals { <IP_ADDRESS>/24; <IP_ADDRESS>/24; }; acl externals { bastion-ips-go-here; }; options { ... ... forward only; forwarders { // forward to external servers bastion-ips-go-here; }; allow-transfer { none; }; // sample allow-transfer (no one) allow-query { internals; externals; }; // restrict query access allow-recursion { internals; }; // restrict recursion ... ... }; zone "site1.example.com" { // sample master zone type master; file "m/site1.example.com"; forwarders { }; // do normal iterative // resolution (do not forward) allow-query { internals; externals; }; allow-transfer { internals; }; }; zone "site2.example.com" { type slave; file "s/site2.example.com"; masters { <IP_ADDRESS>; }; forwarders { }; allow-query { internals; externals; }; allow-transfer { internals; }; }; zone "site1.internal" { type master; file "m/site1.internal"; forwarders { }; allow-query { internals; }; allow-transfer { internals; } }; zone "site2.internal" { type slave; file "s/site2.internal"; masters { <IP_ADDRESS>; }; forwarders { }; allow-query { internals }; allow-transfer { internals; } };
External (bastion host) DNS server config:
acl internals { <IP_ADDRESS>/24; <IP_ADDRESS>/24; }; acl externals { bastion-ips-go-here; }; options { ... ... allow-transfer { none; }; // sample allow-transfer (no one) allow-query { internals; externals; }; // restrict query access allow-recursion { internals; externals; }; // restrict recursion ... ... }; zone "site1.example.com" { // sample slave zone type master; file "m/site1.foo.com"; allow-query { any; }; allow-transfer { internals; externals; }; }; zone "site2.example.com" { type slave; file "s/site2.foo.com"; masters { another_bastion_host_maybe; }; allow-query { any; }; allow-transfer { internals; externals; } };
In the resolv.conf (or equivalent) on the bastion host(s):
search ... nameserver <IP_ADDRESS> nameserver <IP_ADDRESS> nameserver <IP_ADDRESS>
This is a short guide to setting up Transaction SIGnatures (TSIG) based transaction security in BIND. It describes changes to the configuration file as well as what changes are required for different features, including the process of creating transaction keys and using transaction signatures with BIND.
BIND primarily supports TSIG for server to server communication. This includes zone transfer, notify, and recursive query messages. Resolvers based on newer versions of BIND 8 have limited support for TSIG.
TSIG might be most useful for dynamic update. A primary server for a dynamic zone should use access control to control updates, but IP-based access control is insufficient. Key-based access control is far superior, see Proposed Standards. The nsupdate program supports TSIG via the -k and -y command line options.
A shared secret is generated to be shared between host1 and host2. An arbitrary key name is chosen: "host1-host2.". The key name must be the same on both hosts.
The following command will generate a 128 bit (16 byte) HMAC-MD5 key as described above. Longer keys are better, but shorter keys are easier to read. Note that the maximum key length is 512 bits; keys longer than that will be digested with MD5 to produce a 128 bit key.
dnssec-keygen -a hmac-md5 -b 128 -n HOST host1-host2.
The key is in the file Khost1-host2.+157+00000.private. Nothing directly uses this file, but the base-64 encoded string following "Key:" can be extracted from the file and used as a shared secret:
Key: La/E5CjG9O+os1jq0a2jdA==
The string "La/E5CjG9O+os1jq0a2jdA==" can be used as the shared secret.
The shared secret is simply a random sequence of bits, encoded in base-64. Most ASCII strings are valid base-64 strings (assuming the length is a multiple of 4 and only valid characters are used), so the shared secret can be manually generated.
Also, a known string can be run through mmencode or a similar program to generate base-64 encoded data.
This is beyond the scope of DNS. A secure transport mechanism should be used. This could be secure FTP, ssh, telephone, etc.
Imagine host1 and host 2 are both servers. The following is added to each server's named.conf file:
key host1-host2. { algorithm hmac-md5; secret "La/E5CjG9O+os1jq0a2jdA=="; };
The algorithm, hmac-md5, is the only one supported by BIND. The secret is the one generated above. Since this is a secret, it is recommended that either named.conf be non-world readable, or the key directive be added to a non-world readable file that is included by named.conf.
At this point, the key is recognized. This means that if the server receives a message signed by this key, it can verify the signature. If the signature succeeds, the response is signed by the same key.
Since keys are shared between two hosts only, the server must be told when keys are to be used. The following is added to the named.conf file for host1, if the IP address of host2 is <IP_ADDRESS>:
server <IP_ADDRESS> { keys { host1-host2. ;}; };
Multiple keys may be present, but only the first is used. This directive does not contain any secrets, so it may be in a world-readable file.
If host1 sends a message that is a request to that address, the message will be signed with the specified key. host1 will expect any responses to signed messages to be signed with the same key.
A similar statement must be present in host2's configuration file (with host1's address) for host2 to sign request messages to host1.
BIND allows IP addresses and ranges to be specified in ACL definitions and allow-{ query | transfer | update } directives. This has been extended to allow TSIG keys also. The above key would be denoted key host1-host2.
An example of an allow-update directive would be:
allow-update { key host1-host2. ;};
This allows dynamic updates to succeed only if the request was signed by a key named "host1-host2.".
You may want to read about the more powerful update-policy statement in Section <IP_ADDRESS>.
The processing of TSIG signed messages can result in several errors. If a signed message is sent to a non-TSIG aware server, a FORMERR will be returned, since the server will not understand the record. This is a result of misconfiguration, since the server must be explicitly configured to send a TSIG signed message to a specific server.
If a TSIG aware server receives a message signed by an unknown key, the response will be unsigned with the TSIG extended error code set to BADKEY. If a TSIG aware server receives a message with a signature that does not validate, the response will be unsigned with the TSIG extended error code set to BADSIG. If a TSIG aware server receives a message with a time outside of the allowed range, the response will be signed with the TSIG extended error code set to BADTIME, and the time values will be adjusted so that the response can be successfully verified. In any of these cases, the message's rcode is set to NOTAUTH.
TKEY is a mechanism for automatically generating a shared secret between two hosts. There are several "modes" of TKEY that specify how the key is generated or assigned. BIND implements only one of these modes, the Diffie-Hellman key exchange. Both hosts are required to have a Diffie-Hellman KEY record (although this record is not required to be present in a zone). The TKEY process must use signed messages, signed either by TSIG or SIG(0). The result of TKEY is a shared secret that can be used to sign messages with TSIG. TKEY can also be used to delete shared secrets that it had previously generated.
The TKEY process is initiated by a client or server by sending a signed TKEY query (including any appropriate KEYs) to a TKEY-aware server. The server response, if it indicates success, will contain a TKEY record and any appropriate keys. After this exchange, both participants have enough information to determine the shared secret; the exact process depends on the TKEY mode. When using the Diffie-Hellman TKEY mode, Diffie-Hellman keys are exchanged, and the shared secret is derived by both participants.
BIND 9 partially supports DNSSEC SIG(0) transaction signatures as specified in RFC 2535. SIG(0) uses public/private keys to authenticate messages. Access control is performed in the same manner as TSIG keys; privileges can be granted or denied based on the key name.
When a SIG(0) signed message is received, it will only be verified if the key is known and trusted by the server; the server will not attempt to locate and/or validate the key.
SIG(0) signing of multiple-message TCP streams is not supported.
BIND 9 does not ship with any tools that generate SIG(0) signed messages.
Cryptographic authentication of DNS information is possible through the DNS Security (DNSSEC) extensions, defined in RFC 2535. This section describes the creation and use of DNSSEC signed zones.
In order to set up a DNSSEC secure zone, there are a series of steps which must be followed. BIND 9 ships with several tools that are used in this process, which are explained in more detail below. In all cases, the "-h" option prints a full list of parameters. Note that the DNSSEC tools require the keyset and signedkey files to be in the working directory, and that the tools shipped with BIND 9.0.x are not fully compatible with the current ones.
There must also be communication with the administrators of the parent and/or child zone to transmit keys and signatures. A zone's security status must be indicated by the parent zone for a DNSSEC capable resolver to trust its data.
For other servers to trust data in this zone, they must either be statically configured with this zone's zone key or the zone key of another zone above this one in the DNS tree.
The dnssec-keygen program is used to generate keys.
A secure zone must contain one or more zone keys. The zone keys will sign all other records in the zone, as well as the zone keys of any secure delegated zones. Zone keys must have the same name as the zone, a name type of ZONE, and must be usable for authentication. It is recommended that zone keys use a cryptographic algorithm designated as "mandatory to implement" by the IETF; currently these are RSASHA1 (which is not yet supported in BIND 9.2) and DSA.
The following command will generate a 768 bit DSA key for the child.example zone:
dnssec-keygen -a DSA -b 768 -n ZONE child.example.
Two output files will be produced: Kchild.example.+003+12345.key and Kchild.example.+003+12345.private (where 12345 is an example of a key tag). The key file names contain the key name (child.example.), algorithm (3 is DSA, 1 is RSA, etc.), and the key tag (12345 in this case). The private key (in the .private file) is used to generate signatures, and the public key (in the .key file) is used for signature verification.
To generate another key with the same properties (but with a different key tag), repeat the above command.
The public keys should be inserted into the zone file with $INCLUDE statements, including the .key files.
The dnssec-makekeyset program is used to create a key set from one or more keys.
Once the zone keys have been generated, a key set must be built for transmission to the administrator of the parent zone, so that the parent zone can sign the keys with its own zone key and correctly indicate the security status of this zone. When building a key set, the list of keys to be included and the TTL of the set must be specified, and the desired signature validity period of the parent's signature may also be specified.
The list of keys to be inserted into the key set may also included non-zone keys present at the top of the zone. dnssec-makekeyset may also be used at other names in the zone.
The following command generates a key set containing the above key and another key similarly generated, with a TTL of 3600 and a signature validity period of 10 days starting from now.
dnssec-makekeyset -t 3600 -e +864000 Kchild.example.+003+12345 Kchild.example.+003+23456
One output file is produced: keyset-child.example.. This file should be transmitted to the parent to be signed. It includes the keys, as well as signatures over the key set generated by the zone keys themselves, which are used to prove ownership of the private keys and encode the desired validity period.
The dnssec-signkey program is used to sign one child's keyset.
If the child.example zone has any delegations which are secure, for example, grand.child.example, the child.example administrator should receive keyset files for each secure subzone. These keys must be signed by this zone's zone keys.
The following command signs the child's key set with the zone keys:
dnssec-signkey keyset-grand.child.example. Kchild.example.+003+12345 Kchild.example.+003+23456
One output file is produced: signedkey-grand.child.example.. This file should be both transmitted back to the child and retained. It includes all keys (the child's keys) from the keyset file and signatures generated by this zone's zone keys.
The dnssec-signzone program is used to sign a zone.
Any signedkey files corresponding to secure subzones should be present, as well as a signedkey file for this zone generated by the parent (if there is one). The zone signer will generate NXT and SIG records for the zone, as well as incorporate the zone key signature from the parent and indicate the security status at all delegation points.
The following command signs the zone, assuming it is in a file called zone.child.example. By default, all zone keys which have an available private key are used to generate signatures.
dnssec-signzone -o child.example zone.child.example
One output file is produced: zone.child.example.signed. This file should be referenced by named.conf as the input file for the zone.
Unlike in BIND 8, data is not verified on load in BIND 9, so zone keys for authoritative zones do not need to be specified in the configuration file.
The public key for any security root must be present in the configuration file's trusted-keys statement, as described later in this document.
BIND 9 fully supports all currently defined forms of IPv6 name to address and address to name lookups. It will also use IPv6 addresses to make queries when running on an IPv6 capable system.
For forward lookups, BIND 9 supports both A6 and AAAA records. The use of AAAA records is deprecated, but it is still useful for hosts to have both AAAA and A6 records to maintain backward compatibility with installations where AAAA records are still used. In fact, the stub resolvers currently shipped with most operating system support only AAAA lookups, because following A6 chains is much harder than doing A or AAAA lookups.
For IPv6 reverse lookups, BIND 9 supports the new "bitstring" format used in the ip6.arpa domain, as well as the older, deprecated "nibble" format used in the ip6.int domain.
BIND 9 includes a new lightweight resolver library and resolver daemon which new applications may choose to use to avoid the complexities of A6 chain following and bitstring labels, see Chapter 5.
For an overview of the format and structure of IPv6 addresses, see Section A.3.1.
The AAAA record is a parallel to the IPv4 A record. It specifies the entire address in a single record. For example,
$ORIGIN example.com. host 3600 IN AAAA 3ffe:8050:201:1860:42::1
While their use is deprecated, they are useful to support older IPv6 applications. They should not be added where they are not absolutely necessary.
The A6 record is more flexible than the AAAA record, and is therefore more complicated. The A6 record can be used to form a chain of A6 records, each specifying part of the IPv6 address. It can also be used to specify the entire record as well. For example, this record supplies the same data as the AAAA record in the previous example:
$ORIGIN example.com. host 3600 IN A6 0 3ffe:8050:201:1860:42::1
A6 records are designed to allow network renumbering. This works when an A6 record only specifies the part of the address space the domain owner controls. For example, a host may be at a company named "company." It has two ISPs which provide IPv6 address space for it. These two ISPs fully specify the IPv6 prefix they supply.
In the company's address space:
$ORIGIN example.com. host 3600 IN A6 64 0:0:0:0:42::1 company.example1.net. host 3600 IN A6 64 0:0:0:0:42::1 company.example2.net.
ISP1 will use:
$ORIGIN example1.net. company 3600 IN A6 0 3ffe:8050:201:1860::
ISP2 will use:
$ORIGIN example2.net. company 3600 IN A6 0 1234:5678:90ab:fffa::
When host.example.com is looked up, the resolver (in the resolver daemon or caching name server) will find two partial A6 records, and will use the additional name to find the remainder of the data.
When an A6 record specifies the address of a name server, it should use the full address rather than specifying a partial address. For example:
$ORIGIN example.com. @ 14400 IN NS ns0 14400 IN NS ns1 ns0 14400 IN A6 0 3ffe:8050:201:1860:42::1 ns1 14400 IN A <IP_ADDRESS>
It is recommended that IPv4-in-IPv6 mapped addresses not be used. If a host has an IPv4 address, use an A record, not an A6, with ::ffff:<IP_ADDRESS> as the address.
While the use of nibble format to look up names is deprecated, it is supported for backwards compatibility with existing IPv6 applications.
When looking up an address in nibble format, the address components are simply reversed, just as in IPv4, and ip6.int. is appended to the resulting name. For example, the following would provide reverse name lookup for a host with address 3ffe:8050:201:1860:42::1.
$ORIGIN <IP_ADDRESS>.<IP_ADDRESS>.<IP_ADDRESS>.e.f.f.3.ip6.int. <IP_ADDRESS>.<IP_ADDRESS>.<IP_ADDRESS>.<IP_ADDRESS> 14400 IN PTR host.example.com.
Bitstring labels can start and end on any bit boundary, rather than on a multiple of 4 bits as in the nibble format. They also use ip6.arpa rather than ip6.int.
To replicate the previous example using bitstrings:
$ORIGIN \[x3ffe805002011860/64].ip6.arpa. \[x0042000000000001/64] 14400 IN PTR host.example.com.
In IPV6, the same host may have many addresses from many network providers. Since the trailing portion of the address usually remains constant, DNAME can help reduce the number of zone files used for reverse mapping that need to be maintained.
For example, consider a host which has two providers (example.net and example2.net) and therefore two IPv6 addresses. Since the host chooses its own 64 bit host address portion, the provider address is the only part that changes:
$ORIGIN example.com. host IN A6 64 ::1234:5678:1212:5675 cust1.example.net. IN A6 64 ::1234:5678:1212:5675 subnet5.example2.net. $ORIGIN example.net. cust1 IN A6 48 0:0:0:dddd:: ipv6net.example.net. ipv6net IN A6 0 aa:bb:cccc:: $ORIGIN example2.net. subnet5 IN A6 48 0:0:0:1:: ipv6net2.example2.net. ipv6net2 IN A6 0 6666:5555:4::
This sets up forward lookups. To handle the reverse lookups, the provider example.net would have:
$ORIGIN \[x00aa00bbcccc/48].ip6.arpa. \[xdddd/16] IN DNAME ipv6-rev.example.com.
and example2.net would have:
$ORIGIN \[x666655550004/48].ip6.arpa. \[x0001/16] IN DNAME ipv6-rev.example.com.
example.com needs only one zone file to handle both of these reverse mappings:
$ORIGIN ipv6-rev.example.com. \[x1234567812125675/64] IN PTR host.example.com.


--- layout: post status: publish published: true title: The Ides of March author: display_name: Andy login: Andy email<EMAIL_ADDRESS>url: '' author_login: Andy author_email<EMAIL_ADDRESS>wordpress_id: 2139 wordpress_url: http://ivyenvy.com/?p=2139 date: '2010-03-15 13:47:30 +0000' date_gmt: '2010-03-15 19:47:30 +0000' categories: - Catchers tags: - Geovany Soto - Mark McGwire - Tony La Russa comments: [] ---


class: center, middle # Publishing your first Decentralized website ## 🎉 with Dat 🎉 --- class: center, middle, purplebg # @RangerMauve "Georgiy" [Github](https://github.com/RangerMauve/) [Twitter](https://mobile.twitter.com/RangerMauve) --- class: center, middle ![Geocities Logo](./Geocities-Logo-Geocities.jpg) ??? Remember this? Or have you heard of it before? --- class: center, middle # 😂👍🔥💯 ??? That's the good stuff. It was pretty crude, but it had something that we're missing today. --- class: center, middle, purplebg # ✨🌟 CREATIVITY 🌟✨ ??? The early web was crude, and people didn't know what they were doing. But it encouraged people to be creative and publish their own content online. --- class: center, middle ![Facebook Logo](./flogo_rgb_hex-brc-site-250.png) ??? Have you ever seen this thing? You can make text posts and maybe add images and links. --- class: center, middle ![Twitter Logo](./Twitter_Logo_Blue.png) ??? What about this? You can make short text posts and maybe add images. --- class: center, middle ![Medium Logo](./1_emiGsBgJu2KHWyjluhKXQw.png) ??? What about this cool blogging thing? You can have long text posts and maybe add images. --- class: center, middle # 💤 😪 💤 ??? Yawn! You have very little customization over these platforms. You make some posts, but then it's aggregated by some big faceless company, analized by advertisers, and the shown to some subset of users according to some opaque algorythms. --- class: center, middle, purplebg # 📝😎👍 ??? How about we bring it back and make our own blog, use whatever we want for displaying it, and ignore any of these third parties and publish our content directly. --- class: center, middle # 🤔 ❔ ??? Ok, so that's the blog part, but before we get into that, let's talk about the Peer to peer part. --- class: center, middle # 🤓(📄) -> 🖥 ???  You make your content, but then you have to send it to someone else, a server. --- class: center, middle ## 🖥(📄) <- 🌐 <- 🤩 💻 ??? The server will then hold your content somehow. If somebody wants to view it on their computer, they connect to the internet, find your server, and download the content from it. These servers are essential for loading anything on the web. --- class: center, middle # 🌐 🧙 😐❔🐉 🖥 ??? They're also kinda complicated. Setting up your own server means running some software somewhere, which means getting it in the first place, making sure it's connected to the internet with a stable IP address, and setting up a URL which people can access it at. All this stuff might not seem too complicated to technical people, but for regular people, it might as well be gibberish. --- class: center, middle # ☁ 🖥 ☁ ??? That's why people pay (or indirectly pay) someone else to do it all for them. That can be anything from having someone else manage the hardware, Someone else set up the software for your server, Or totally managed solutions like Social Media where the process is totally abstracted away. The advantage is that you don't have to bother setting all this stuff up. The disadvantage is you have an army of middle-men between you and other people, and they might not have your best interests in mind. --- class: center, middle ### 🤓(📄) -> 🌐 -> 🖥 <- 🌐 <- 🤩(📄) ??? This is great when everything is working. The content creators make some content, it flies over the internet to some server, and eventually it's downloaded from the server by people hungry for content. The thing is, each of those arrows is actually a breaking point. --- class: center, middle ## 🖥💥 -❌-> 🌐 <-❌- 😭 ??? That nice flow breaks down if the server isn't accessible by both parties. This can happen when: - The server software or hardware goes down - The server decides it doesn’t want to share your content with specific people for whatever reason - It’s unable to access the internet (either because of physical outage or governments / targeted attacks) - If there’s a natural disaster that blocks your city’s network from the server’s network - If your home loses internet connectivity for whatever reason And of course, in addition to the loss of service and bottlenecks, someone has to pay for all of this stuff in the middle to be up. These days you pay by having all your entire existence analyzed and sent to advertisers. --- class: center, middle ![Slack Logo](./Slack-icon.png) ??? Who uses Slack? --- class: center, middle ![Slack outages - It's not good](./SlackOutages.PNG) ??? This is the recent downtime reports people have made for it. --- class: center, middle ![Github Logo](./GitHub-Mark.png) ??? Anyone use GitHub? --- class: center, middle ![Github Outages - Not much better](./GithubOutages.PNG) ??? This is theirs --- class: center, middle ## 🤓💻(📄) 🏠 🤩💻 ??? Isn't it weird that our productivity goes right out the window when some company's computer isn't running? Isn't it kinda weird that I can't easily send you a file on slack if I'm in the same location as you unless it goes to some cloud server first? --- class: center, middle, beakerbg ### 🤓 💻(📄) -> ✨P2P✨ -> 🤩 💻 ??? So this is what Peer to Peer technology brings us. You can create some contetn on your computer, and with the magic of p2p, One of your friends can view it on their machine directly. No extra middle men required* ' --- class: center, middle ![Dat Logo](./dat-logo.png) ??? My favorite ecosystem for this is Dat. Dat is a protocol that lets you share folders over a peer to peer network with the ability to send updates across the network, and being able to view older versions. --- class: center, middle, beakerbg # [Beaker](https://beakerbrowser.com) ![Beaker Browser Logo](./beaker-logo.png) ??? On top of Dat, we've got a great tool called Beaker which a Web Browser that enables you to load and author websites on the p2p web. --- class: center, middle, purplebg # ⌨ 😎 Coding time 😎⌨ ??? - Get people to install Beaker/Cliqz on their device - Get people to load a P2P website on their device - Get people to create a fresh Dat archive and explain what that means - Show some basic HTML formatting - Get people to write a quick blurb about something they're interested in - Show how they can add a file to their archive and link to it (dancing baby gif) - Spice up their website with 90's web aesthetics, thick borders, background images, `
` --- class: center, middle, datbg # 🎉 😎 Sharing time 😎 🎉 ??? - Get people to share their website with the person next to them - Have them post their dat URL in the chat - Encourage people to pick a random URL that they see, and edit it --- class: center, middle, datbg # 💾 Persistence 💾 ??? - Show people how to get their website onto a storage provider like hashbase, and why - Refresh chat page and have people post their Dat URLs if they want it to be pinned --- class: center, middle, purplebg # 💯🔥Thank you! 😂👍


"HAMBURGER HILL" (1987) a film by John Irvin reviewed by Anna G. McDougald
****1/2 out of *****
More than a decade before Steven Spielberg's SAVING PRIVATE RYAN asked whether a film could be both "anti war" and "pro-soldier", John Irvin's HAMBURGER HILL proved it could. Lost in the innundation of critical acclaim that greeted Oliver Stone's PLATOON, this excellent film was dismissed as "too militaristic". It's hard to understand exactly why---unless Irvin, in assembling his motley collection of young men who for predictable (and often naive) reasons "chose to show up" for the Vietnam debacle, ---has refused to present us with the stone killer, drug-stoked psycho, and ruthless opportunist who have become to Vietnam war epics what "the Polack, the Hillbilly and the Kid from Brooklyn" became to WWII movies.
HAMBURGER HILL, based on a true story, is not an easy film to watch. There is a scene that will have graying anti-war activists squirming in their seats, or moved to genuine tears. And the climactic final assault on the "Hill" in question is visually confusing. Gristly realities are presented in brief flashes, as if the brain dared not acknowledged what it had encountered. And in the mud and smoke officer and enlistee, veteran and "newbie", black soldier and white, become almost indistinguishable from each other, as they do in the chaos of actual combat. The acting throughout is solid with an absolutely stellar performance rendered by Courtney B. Vance as Doc--in a role that will have many flatly disbelieving that this is same actor they cheered as "Seaman Jones" in McTiernan's RED OCTOBER.
If you've seen PRIVATE RYAN, you owe it to yourself to see HAMBURGER HILL--if only to realise that all the valor and horror of Spielberg's vision was as present in the Ashau Valley as it was at Omaha Beach.
-----== Posted via Deja News, The Leader in Internet Discussion ==----- http://www.dejanews.com/rg_mkgrp.xp Create Your Own Free Member Forum
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


A set of examples showing some of what chuckle can do!
All examples are shown here together, each can be found in the examples directory.


4 0 4
A fatal exception 404 has occurred at C0DE:ABAD1DEA in 0xC0DEBA5E.
The current request will be terminated.
* Press any key to return to the previous page.
* Press CTRL+ALT+DEL to restart your computer. You will
lose any unsaved information in all applications.
Press any key to continue...█
{% endblock %}


About Me
I am an arduous engineering student passionate about aerodynamics, data science, 3D modelling, and web development.
Education
Purdue University
August '17 - Present
First-Year Engineering Program
My Skills
Computer-Aided Design
- CATIA
- Inventor
- AutoCAD
- Solidworks
- 3ds Max
Web Development
- HTML
- CSS
- JavaScript
- jQuery
- Bootstrap
Non-Technical
- Initiative
- Leadership
- Communication
- Adaptibility
- Creativity