This is Arthur Lemmens' talk given at the ECLM 2006 in Hamburg
Introduction
EXPERTISE
Maybe I should start by saying that I don’t consider myself an expert on any of the subjects that I’m going to talk about today (except maybe Lisp programming). But I’ve been wanting a Lisp persistence library for years, and nobody else was writing it for me (or, if they were writing them, they lacked features that I considered essential).
So here we are…
FEATURES
Rucksack is a persistence library for Common Lisp. It’s a bit similar to systems like AllegroCache or PLOB, but it’s also different in some important respects. Here are some of its features:
-
Common Lisp only
-
99% portable
-
persistent conses, vectors, CLOS objects, …
-
object cache
-
parallel transactions
-
incremental garbage collector
-
schema evolution
-
use MOP to automatically deal with slot changes
-
btree indexing for class instances and slot values
-
flexible architecture
-
not finished
Also:
-
it’s all written in Common Lisp
-
it’s almost all portable, except for process locks and some MOP magic (I write and test it with Lispworks)
-
it tries to provide persistent equivalents of Lisp’s classical data structures, including persistent conses, persistent vectors and persistent CLOS instances.
-
it has an object based cache; changes to persistent objects are written to disk (serialized) during a transaction-commit
-
it supports parallel transactions
-
it has an incremental garbage collector
-
it support schema evolution, in the sense that it can deal with changes to persistent class definitions in a way that’s similar to what CL provides with update-instance-for-redefined-class
-
it uses the MOP to automatically deal with slot changes
-
it provides indexing for instances and slot values Btrees are included, user defined indexes are also possible.
-
I try hard to keep it flexible and readable, so it should be relatively easy to adapt to your own needs.
-
it’s not finished yet I’ve written code for almost everything mentioned above, but there are still quite a few loose ends and it needs some heavy testing.
THIS TALK
-
serialization How do I get it on disk?
-
object ids How do I know where I put it?
-
cache Déjà vu.
-
garbage collection How do I get rid of this mess?
-
parallel transactions Have my cake and eat it too.
-
failure recovery What if somebody pulls the plug?
-
automatic slot and class indexing How do I find it back?
-
schema evolution What if my class definition changes?
I’m going to present Rucksack in about the same order as I developed it. This means we’ll start at the bottom, with things like serialization, object ids, cacheing and garbage collection. Then we’ll move on to headache stuff like parallel transactions, recovering from failure, using the MOP for automatic slot and class indexing, and schema evolution.
THE JUNGLE
Writing a persistence library is like hacking your way through a jungle. At each point there are difficult decisions to make, and making the best decision is almost impossible. In fact, what’s best will often depend on the application.
Garbage collection is a nice example. One week I thought I should write a mark-and-sweep collector, the next week I thought that a copying collector would be better. Or maybe some kind of mixture? I ended up writing half a copying collector, then changed my mind and wrote a mark and sweep collector. Now I’m having doubts again.
But this is nothing new for most Common Lisp programmers. We’re used to the fact that there is no single best programming paradigm, no single best answer. Instead, Common Lisp provides a flexible programming framework that you can adapt to the problem at hand. I try to do the same for Rucksack.
Objects on disk: serialization
INTRO
The serializer is the low level layer that takes care of writing objects to disk and reading them back again.
SHARED OBJECTS
One of the things that can complicate serialization is that the serializer must deal with shared objects in such a way that they can be reconstructed correctly by the 'deserializer'. This can have quite a large effect on the memory usage of a serializer (there’s a reason why Common Lisp has the print-circle flag).
Fortunately, we don’t need to worry about shared objects when we’re serializing in Rucksack: Rucksack only respects the object identity of objects that are explicitly declared to be persistent objects. (Erm, well, that’s not entirely true: there are some corner cases like symbols and packages, but I’m not going to go into that now.)
WHY NOT WRITE AND READ
If you know that you don’t need to worry about shared objects, serializing objects to disk is easy. In principle, you could just use Common Lisp’s WRITE function to write the object to disk. Then you can use READ to deserialize the object when you need it again.
This is possible, but it would be slow. Lisp’s syntax for representing data was designed to be writable and readable by humans. The serializer doesn’t have to worry about human readability, so it can make decisions that allow for smaller representations and much faster reading. In my experience, the speed difference can easily be one or two orders of magnitude.
Two examples:
-
'Container objects' like vectors and lists are prefixed by the number of elements they contain. This means that the deserializer can pre-allocate a container of exactly the right size.
-
The serializer prefixes every object by its type. This is not necessarily equivalent to a Common Lisp type, but gives enough information to the deserializer so that it can prepare itself for what’s coming.
MARKERS
(defconstant +minus-one+ #x09)
(defconstant +zero+ #x0A)
(defconstant +one+ #x0B)
(defconstant +two+ #x0C
(defconstant +object+ #x70)
(defconstant +unbound-slot+ #x71)
(defconstant +shared-object-definition+ #x72)
(defconstant +shared-object-reference+ #x73)
(defconstant +hash-table+ #x80)
(defconstant +pathname+ #x90)
(defconstant +array+ #xA0)
The markers above are hard wired constants and I define them explicitly. This may look a bit un-lispy; I’ve seen other serialization libraries where the marker numbers automatically roll out of some macro. I don’t do that. I do it the old-fashioned way because I want a well defined file format for Rucksack; there should not be any implementation or platform dependencies in Rucksack’s file format.
CODE FRAGMENT: DESERIALIZE
(defun deserialize (serializer &optional (eof-error-p t) (eof-value nil))
"Reads the next object from the serializer stream. Signals an end-of-file
error or returns EOF-VALUE when the end of the stream is reached."
(let ((marker (read-next-marker serializer)))
(if marker
(deserialize-contents marker serializer)
;; End of file
(if eof-error-p
(error 'end-of-file :stream serializer)
eof-value))))
The top-level DESERIALIZE function just reads a marker and then calls the generic function DESERIALIZE-CONTENTS. DESERIALIZE-CONTENTS has a different method for each marker.
For example:
SERIALIZING A HASH TABLE
(defmethod serialize ((hash-table hash-table) stream)
(serialize-marker +hash-table+ stream)
;; Hash-table-test is guaranteed to return a symbol (for the
;; standardized hash-table test functions), so that's nicely
;; portable.
(serialize (hash-table-test hash-table) stream)
(serialize (hash-table-size hash-table) stream)
(serialize (hash-table-rehash-size hash-table) stream)
(serialize (hash-table-rehash-threshold hash-table) stream)
(serialize (hash-table-count hash-table) stream)
(maphash (lambda (key value)
(serialize key stream)
(serialize value stream))
hash-table))
DESERIALIZING IT AGAIN
(defmethod deserialize-contents ((marker (eql +hash-table+)) stream)
(let* ((test (deserialize stream))
(size (deserialize stream))
(rehash-size (deserialize stream))
(rehash-threshold (deserialize stream))
(count (deserialize stream)))
(let ((table (make-hash-table :test test
:size size
:rehash-size rehash-size
:rehash-threshold rehash-threshold)))
(loop repeat count
do (let* ((key (deserialize stream))
(value (deserialize stream)))
(setf (gethash key table) value)))
table)))
OBJECTS THAT CAN’T BE SERIALIZED
Some Lisp objects can’t be serialized portably: structs and function objects are the most obvious examples. I think that not serializing those is a small price to pay for portability, but I suppose there are exceptions
FINDING/UPDATING OBJECTS: OBJECT TABLE, CACHE
INTRO
That was easy.
So now we’re able to save normal Lisp objects to disk. And we can even load them back later. This means we’re doing fine for settings where we can dump the entire world from time to time, and load it back when we need it.
For many applications, this is all that’s needed. And a good serializer can be orders of magnitude faster than using WRITE/READ or writing MAKE-LOAD-FORM methods, so we’re already ahead of the game.
SERIALIZING PERSISTENT OBJECTS
Things get more interesting when we need to serialize persistent objects. For persistent objects we must make sure that we respect object identity, for example. And we must save some kind of representation of the object’s class, so we can recreate it correctly. And we must save all slot values, so we need some simple MOP magic to find all slots.
 But we don’t want to save her twice. When serializing either DICK or MARY, we just save a reference to JANE.
When we deserialize DICK (or MARY) at a later point, we don’t deserialize JANE either. Instead we fill the CHILD slot of DICK with a proxy. Only when the application tries to read DICK’S CHILD slot will the JANE object be loaded into memory by the deserializer.
SLOT-VALUE-USING-CLASS
We use the MetaObject Protocol to detect whenever a persistent slot is being accessed. Here’s the method that makes sure that proxies are automatically dereferenced at the right moment:
(defmethod slot-value-using-class :around ((class persistent-class)
object
slot)
;; Automatically dereference proxies.
(declare (ignore class slot))
(maybe-dereference-proxy (call-next-method)))
We have similar methods on (SETF SLOT-VALUE-USING-CLASS)
to hook into
slot writes and on INITIALIZE-INSTANCE to do the right thing when a
new persistent object is created in memory.
PROXIES
Here’s the definition of a proxy in Rucksack:
(defclass proxy ()
((object-id :initarg :object-id :reader object-id)
(rucksack :initform (current-rucksack)
:initarg :rucksack :reader rucksack))
(:documentation "Proxies are some kind of in-memory forwarding pointer
to data in the cache. They are never saved on disk."))
Instead of a class like this, we could also have used plain object ids (no-nonsense raw integers) to represent the objects. This would be more efficient, but it has two problems:
-
It would become quite difficult to work with more than one rucksack at a time, because you’d need to keep track of which object id belongs to which rucksack in your application code.
 This means that the application programmer will have to dereference proxies by hand instead of having it done automatically by the compiler (unless you force a static distinction between slots that always contain proxies and slots that contain other value; but such a rigid distinction wouldn’t really fit with Lisp’s dynamic programming style).
UPDATING PERSISTENT OBJECTS
One question that I had to answer for Rucksack is: how are slot values of persistent objects updated on disk? I’ve made a big choice that has a strong influence on rest of Rucksack: objects on disk are never overwritten (as long as they can be referenced). Instead of serializing a new version of an object into the same disk space as an old version, the new version is serialized into some new, freshly allocated space on disk.
I’ll return to this decision later, when I talk about parallel transactions and recovering from crashes.
CHOICE: OBJECT TABLE, DIRECT POINTERS, BTREES?
Another choice that a persistence library has to make is: given an object ID, how do I find the corresponding object? How do I find the disk position of the object, so my deserializer can reconstruct it in memory when I need it?
For Rucksack, I’ve considered three possibilities:
-
Use the disk position itself as the object ID. So an object ID would be pretty much like a normal pointer in memory.
-
Use an 'object vector': the vector is indexed by object identifiers, and each vector element contains the disk position of the object.
-
Use a more complicated indexing scheme (btrees, for example).
In fact, I’m still considering these possibilities. At the moment, Rucksack uses the second scheme. Each rucksack directory has a file called 'heap', which contains serialized versions of all objects, and a file called 'objects', which contains a straightforward mapping from object IDs to object positions on disk.
CACHE
So the object table and the serializer give us a way to reconstruct an object, given its ID. But reconstructing an object from its ID is an expensive operation. We may want to cache this. Keeping a cache of recently reconstructed objects may speed up our programs a lot.
GETTING AN OBJECT FROM THE CACHE
Here’s a code fragment from an old version of Rucksack that shows the basic working of the cache:
(defmethod cache-get-object (object-id (cache standard-cache))
(let ((result (or (gethash object-id (objects cache))
(gethash object-id (dirty-objects cache))
(let ((object (load-cached-object object-id cache)))
;; Add to in-memory cache.
(when (cache-full-p cache)
(make-room-in-cache cache))
(setf (gethash object-id (objects cache)) object)
object))))
;; Put it (back) in front of the queue.
(add-to-queue object-id cache)
result))
So we keep a hashtable of objects that have been loaded from disk and a separate hashtable of objects that have been changed since they were loaded. If we can’t find an object in one of those hashtables we load it from disk.
LOWER-LEVEL CACHES
I’ve never written a relational database or even looked at the code for one, but I’ve tried to read some of the database literature. From that literature I get the impression that relational databases usually do their caching on a much lower level than what I just described. For example, here’s a quote from "Database Systems: The Complete Book" by García-Molina, Ullman & Widom:
A DBMS will manage disk blocks itself, rather than relying on the operating system's file manager to move blocks between main and secondary memory.
I haven’t taken that route for Rucksack, and I’ve decided to ignore issues like the size of disk blocks entirely, mostly because:
-
I hope that the operating system will take care of this
-
I want to keep Rucksack as simple as possible
-
I want Rucksack to be written in portable Common Lisp, which doesn’t know the concept of disk blocks.
GARBAGE COLLECTION
DELETE-INSTANCE: YES OR NO?
One question that persistence libraries need to answer is:
Do we provide a way to delete a persistent object, so that it won't be 'loadable' anymore and its disk space can be reused?
This question is very similar to the old manual versus automatic memory management question. Of course, Lispers already knew the answer to that question before I was born: manual memory management is a sin. And it isn’t even a pleasant one.
Somehow the question looks different when we’re dealing with persistence. But as soon as you introduce a function that takes an object ID and removes the corresponding object from the persistent store in such a way that it can’t be loaded again, you basically introduce 'dangling pointers' again.
Welcome back to 'pointer hell'!
So… While I’m uncertain about many of the decisions I’ve made for Rucksack, I’m pretty sure about this one:
There will be no delete-instance. Every object id that's visible to the programmer will always refer to a valid persistent object, so there will be no 'dangling pointers'. When necessary, a garbage collector will take care of reclaiming unused disk space. To ensure that an object will never be visible again, you can remove it from all objects that contain a reference to it. This is exactly how we normally deal with non-persistent objects in Lisp.
(I believe Martin Cracauer may tell us that garbage collection is a decadent luxury and that real programmers don’t need it. And he would probably be right too, if you absolutely need to squeeze maximum performance out of your system. But Rucksack is designed with slightly more modest performance goals, and slightly less modest usability goals. )
THE GARBAGE COLLECTOR
I don’t have time to discuss all details of the memory manager and the garbage collector, so I’ll briefly describe the basics.
I’ve considered both copying and mark-and-sweep collectors. One advantage of a copying collector is that it automatically defragments the heap, and that allocating space for a new object can be trivial: you just serialize it to the end of the heap file.
The biggest problem I see with a copying collector is that it becomes inefficient if you have many big objects that don’t contain references to other objects (for example the contents of binary files that we want to keep in the database): these objects will need to be copied during each collection.
An application I wrote a while ago is a simple publication archive that fits this model: not much 'structured data' and fairly many binary files, with sizes ranging from a few hundred KB to about 100 MB. When I was writing my copying collector, I began to imagine my collector spending 99 % of its time just copying these files. Now I’m usually not the kind of programmer who tries to squeeze the last bit of performance out of his programs, but this looked painful even to me.
So I decided to try my luck with a mark and sweep collector.
 If you use the object vector that I described earlier, this is very easy to do. Each element of the object vector reserves a few bits for the garbage collector. One of these bits is the so called mark bit. So we just loop across the vector, clearing the mark bit.
-
MARK
Now all live objects are traced, beginning with the so called root set. Each object that can be reached from the root set is marked 'alive' again. All other objects will remain marked 'dead', which is exactly what we need.
-
SWEEP
Now the entire heap is 'sweeped', object after object, from left to right. The disk space for each object that is marked dead is returned to a free list.
MAKING IT INCREMENTAL
This works well and is not too difficult to implement. But for big databases it can take a while (minutes, maybe even hours) to run. If you’re writing web servers or other programs that continually need to be able to handle user requests, this is unacceptable.
So I made it incremental.
To make a garbage collector incremental, you need to do two things:
-
The first thing is that the collector must be able to do its work in many small steps. (The most obvious moment to run such a small step is just after some disk space has been allocated for a new object.) Each small step must know where it should continue the work of the previous small step. In other words, all the state that’s normally kept in local variables on the stack must now be registered in slots of the garbage collector object.
(defclass mark-and-sweep-heap (garbage-collector free-list-heap serializer)
((state :initform :ready
:type (member :starting
:marking-object-table
:scanning
:sweeping-heap
:sweeping-object-table
:finishing
:ready)
:accessor state)
;; Some counters that keep track of the amount of work done by
;; the garbage collector.
(nr-object-bytes-marked :initform 0 :accessor nr-object-bytes-marked)
(nr-heap-bytes-scanned :initform 0 :accessor nr-heap-bytes-scanned)
(nr-heap-bytes-sweeped :initform 0 :accessor nr-heap-bytes-sweeped)
(nr-object-bytes-sweeped :initform 0 :accessor nr-object-bytes-sweeped)))
As you can see in the code fragment, there isn’t really that much state to keep track of.
The second thing is that the garbage collector needs to know how much work it should do at each step. An effective way is to divide the size of the free heap space by the size of the heap that still needs to be garbage collected and try to keep that number more or less constant.
In formula form you get something like:
New / Free = DoNow / Do
so: DoNow = (New / Free) * ToDo
New : number of new bytes allocated at this step
Free : number of free bytes in the heap
DoNow : number of bytes to collect at this step
Do : number of bytes to collect during this
garbage collection
Fortunately, you don’t need a degree in mathematics to understand this formula.
TRANSACTIONS
ATOMICITY, ISOLATION, DURABILITY
Changes to data often need to occur in so called 'atomic' groups. This means that either all of the changes should be executed, or none of them should be executed. Such an all-or-nothing group of changes is usually called a transaction. When an error occurs in the middle of a transaction, all changes that were executed by the transaction must be undone: this is called a 'rollback'. When the transaction has finished without any errors, all changes must be saved to disk: this is called a 'commit'.
Apart from atomicity ('all-or-nothingness') and durability (saving all changes) another important requirement for transactions is that they may not interfere with each other. As long as a transaction hasn’t committed its changes, it must run as if it were the only transaction using the database. In other words, it must appear to be 'isolated' from all other transactions.
Bank accounts are a popular example when discussing transactions. Let’s look at the following function to transfer money from one account to another.
(defun transfer-money (amount account-a account-b)
"Transfer AMOUNT from ACCOUNT-A to ACCOUNT-B."
(with-transaction ()
;; Check that there's enough money in the account.
(unless (plusp (- (slot-value account-a 'balance) amount))
(error "Not enough money."))
;; Subtract the amount from account A.
(decf (slot-value account-a 'balance) amount)
;; Add the same amount to account B.
(incf (slot-value account-b 'balance) amount)))
Now suppose two transactions T1 and T2 are trying to transfer 100 EURO from an account that contains 150 EURO. If the bank is not careful, we could get the following sequence of events:
-
T1: check that there’s enough money → OK
-
T2: check that there’s enough money → OK
-
T1: subtract 100 EURO from the account → now it contains 50 EURO.
-
T2: subtract 100 EURO from the account → OOPS.
This is one kind of error that can happen when two transactions are not isolated from each other.
POSSIBLE SOLUTIONS
To guarantee that transactions run in isolation, we could:
-
Let the application programmer worry about it and write locking code where necessary.
I haven't chosen this solution. Keeping transactions isolated is a difficult problem where it's easy to make mistakes that are hard to detect.
-
Use some kind of automatic locking.
The best known automatic locking strategy is called "two phase locking". This basically means that a transaction acquires a lock for each object that it wants to change, and then doesn't release the lock until the entire transaction has finished.
I haven't chosen this solution either. One potential problem with two phase locking is that long-running transactions (for example a transaction that looks at all bank accounts to make a monthly report) can easily lock up all other transactions. Now there may be solutions for this too, but I felt these were getting too complicated.
RUCKSACK’S SOLUTION
So what does Rucksack do? It uses so called 'optimistic concurrency control' combined with 'multiple object versions'.
'Optimistic concurrency control' means that Rucksack doesn’t use locks to keep its transactions isolated from each other. Instead it just rolls back a transaction when it is trying to change data that it shouldn’t change, basically telling it to 'try again later'.
Rolling back and retrying a transaction can be rather expensive; that’s why this strategy is called 'optimistic': it assumes that this kind of transaction conflict happens rarely.
Rucksack tries to make transaction conflicts more rare by using multiple object versions. With multiple object versions, each transaction that modifies an object gets its own copy of that object.
This means that an older transaction can stay in its own consistent little world and happily keep reading older versions of objects that are already being changed by younger transactions. So one transaction can have its cake while another transaction is eating it ;-)
That doesn’t mean that both transactions can be eating the cake at the same time, of course. In that case, Rucksack will abort the second transaction that tries to eat the cake and give it an opportunity to retry later. If there’s any cake left, of course.
SAFETY NET
The fact that Rucksack uses optimistic concurrency control does not mean that you can’t use manual or automatic locking on a higher level. It would be possible to use manual locking and treat Rucksack’s transaction conflict detection mechanism as a sort of safety net, for example.
DETECTING CONFLICTS
So how are transaction conflicts detected?
Each transaction has a unique ID. For each version of each object, we register the ID of the transaction that created/modified the object. The ID also functions as a relative timestamp: transaction A is older than transaction B if its ID is less than the ID of transaction B.
Each object creation/modification always happens in the context of a transaction. A transaction conflict occurs when an old transaction tries to modify an object that was modified by a younger transaction.
(Actually, there only needs to be a serialization conflict when an old transaction tries to modify a slot that was modified by a younger transaction. But Rucksack detects conflicts at the object level, not the slot level.)
TRANSACTIONS AND THE CACHE
Before we had transactions, the cache was relatively simple: it kept a set of 'clean' objects: objects that had been read from disk but had not been changed and a set of 'dirty' objects: objects that had been modified and needed to be written back to disk.
With multiversion transactions, this design needs to change.
Here’s a simplified version of Rucksack’s class definition for CACHE:
(defclass standard-cache (cache)
((heap :initarg :heap :reader heap)
(schema-table :initarg :schema-table :reader schema-table)
(commit-file :reader commit-file)
;; Clean objects
(objects :initarg :objects :reader objects)
(highest-transaction-id :initarg :highest-transaction-id
:initform 0
:accessor highest-transaction-id)
(transactions :initform (make-hash-table)
:reader transactions
:documentation "A mapping from transaction ids to
transactions. Contains only open transactions, i.e. transactions that
haven't been rolled back or committed.")))
And here’s the definition of TRANSACTION:
(defclass standard-transaction (transaction)
((id :initarg :id :reader transaction-id)
(dirty-objects :initform (make-hash-table)
:reader dirty-objects
:documentation "A hash-table (from id to object)
containing all objects of which the slot changes have not been written
to file yet.")))
GETTING OBJECTS FROM THE CACHE
So what happens when an object must be retrieved from the cache?
With multiple object versions, a transaction is only allowed to see the version that it has modified itself. Or, if it hasn’t modified the object, the version that was modified by the youngest transaction that’s older than itself.
For example: if the current transaction is #3, and the object has been modified by transactions #1 and #5. Then the 'compatible' object version is the one that was modified by #1.
(defmethod cache-get-object (object-id (cache standard-cache))
(let ((transaction (current-transaction)))
(or ;; Unmodified, already loaded and compatible with the
;; current transaction? Fine, let's use it.
(let ((object (gethash object-id (objects cache))))
(and object
(<= (transaction-id object) (transaction-id transaction))
object))
;; Modified by an open transaction? Try to find the
;; 'compatible' version.
(find-object-version object-id transaction cache)
;; Not in memory at all? Then load the compatible version
;; from disk.
(multiple-value-bind (object most-recent-p)
(load-object object-id transaction cache)
(when most-recent-p
;; Add to in-memory cache if the loaded object is
;; the most recent version of the object.
(when (cache-full-p cache)
(make-room-in-cache cache))
(setf (gethash object-id (objects cache)) object))
object))))
ROLLING BACK A TRANSACTION
When a transaction is rolled back, all side effects of the transaction must be undone. There must be no noticeable difference between an rolled back transaction and a transaction that hasn’t even started yet.
Rolling back is only possible for a transaction that hasn’t been committed yet (and is not currently being committed). This makes rolling back easy: the transaction can basically just clear its dirty objects table to ensure that no changes to those objects will be written to disk.
So here’s some more code:
(defmethod transaction-rollback-1 ((transaction standard-transaction)
(cache standard-cache)
(rucksack standard-rucksack))
(clrhash (dirty-objects transaction))
(queue-clear (dirty-queue transaction))
(close-transaction cache transaction))
CRASHES AND TRANSACTION RECOVERY
RECOVERY
The main problem for recovery is that a transaction commit may fail halfway. This would result in an inconsistent state. To preserve consistency, we need to undo the effects of the partially committed transaction.
As usual, there are different ways of doing this. And, as usual, I’ve tried to find a strategy that’s relatively simple to implement, integrates well with the rest of Rucksack and is a bit different from the most popular way of doing this.
Rucksack’s recovery strategy is based upon two ideas:
-
The most important idea is that we can use the fact that Rucksack never actually overwrites objects but always creates new versions.
-
The second idea is that Rucksack saves a summary of what a transaction commit is going to do to a separate file, a so called 'commit file'. After saving the summary of what it’s going to do, it actually does it and then deletes the summary again. If a transaction-commit fails halfway, the recovery procedure can undo the partial effects of the failed transaction by use the information in the commit file.
COMMIT FILE
The following code shows how commit files are created.
(defun create-commit-file (transaction cache)
"Write object ids of all dirty objects to the commit file, so
recovery can do its job if this transaction never completes."
(with-open-file (stream (commit-filename cache)
:direction :output
:if-exists :supersede
:if-does-not-exist :create)
(serialize (transaction-id transaction) stream)
(serialize (hash-table-count (dirty-objects transaction)) stream)
(loop for object-id being the hash-key of (dirty-objects transaction)
do (serialize object-id stream))))
So the commit file contains the transaction id of the transaction that’s going to be committed and it contains the object ids of all objects that are going to be committed.

RECOVERING
Whenever Rucksack is started, it checks to see if there’s a commit file left. If there is, it knows that is being started after a crash. It will then investigate all object ids that were saved in the commit file. For each object that contains a version created by the unfinished transaction, it will remove that version from the object version list.
After that, it can resume normal operation.
INDEXING OBJECTS: BTREES, SLOT/CLASS INDEXES, MOP MAGIC
INTRO
So… We know how to save persistent objects and load them back, we can cache the load operation for better performance, we can reclaim unused disk space when necessary, we can use transactions to keep changes isolated from changes in other processes, and we even stand a fair chance of recovering from failure.
What more could we need? Ah yes… Sometimes we want to find some objects we’re interested in without traversing the whole database. In other words, we need a persistent indexing mechanism.
Unlike many other database or persistence libraries, Rucksack builds indexes on top of persistent objects, not the other way round. Maybe this costs us a bit in performance because we can’t use any low level tricks for the indexing. But in return for that we get a flexible and easily extendible indexing mechanism.
Here’s how it works:
MORE MOP MAGIC
We already needed some MOP magic to hook into SLOT-VALUE-USING-CLASS and INITIALIZE-INSTANCE for persistent objects. Now we need some more magic to add our own slot and class options for specifying indexes.
This means we can specify something like the following:
(defclass person ()
((name :index (btree :key< string< :key= string=))
(year-of-birth :index (btree :key< < :key= =))
(age :persistence nil))
(:indexed t)
(:metaclass persistent-class))
You see an :INDEX slot option being used for the NAME and YEAR-OF-BIRTH slots, a :PERSISTENCE slot option for the AGE slot and an :INDEX class option for the whole PERSON class.
Let’s look at the class option first: by specifying :INDEXED T, we specify that the object IDs of all instances of this class (or one of its subclasses) will be added to an index. Then the generic function RUCKSACK-MAP-INSTANCES can be used to iterate over all instances of this class (or one of its subclasses, unless those subclasses have an :INDEXED NIL class option).
For slot options the situation is similar, except that you can use so called index specs to specify explicitly what kind of indexing should be used. An index spec has a simple structure: it is either a symbol or a list. If it’s a symbol, it’s the name of an index class. If it’s a list, the car of the list is the name of an index class, and the cdr contains a plist of initargs for the index.
The index class can be an arbitrary class (including classes that you define yourself) as long as it’s persistent and follows a simple indexing protocol. At the moment, Rucksack has only one index class: a no-nonsense, catch-as-catch-can implementation of btrees, written on top of persistent conses and persistent vectors.
INDEXES AND GARBAGE COLLECTION
All class and slot indexes are automatically added to Rucksack’s set of root objects, so indexed objects won’t be removed by the garbage collector. All non-indexed objects are NOT part of the root set, so they will be garbage collected if they’re unreachable from one of the indexes.
QUERIES (if time left)
I think it should be relatively easy to build a simple query language on top of RUCKSACK-MAP-INSTANCES and RUCKSACK-MAP-SLOT-VALUES. This should make it possible to generate relatively efficient code for queries like:
(select 'event
(lambda (event) ...)
:where '(and (string= name "ECLM")
(= year 2006))
:order-by 'name)
I think there’s quite a bit of literature on query optimization and Lisp’s fantastic code transformation and run-time compilation features may add some interesting new possibilites to the standard repertoire. But that’s still open territory. At least for me ;-)
MULTI-DIMENSIONAL INDEXES (if time left)
Another interesting Rucksack extension that I haven’t written yet would be to define multi-dimensional indexes (i.e. indexes that look at the value of more than one slot).
For example:
(defclass point ()
((x :type number)
(y :type number))
(;; Don't use standard indexing (by object id), because we're not
;; interested in EQL-ness for points.
:indexed nil
;; Index points by their coordinates instead.
:index ((x y) (2d-index :key< (< <) :key= (= =))))
(:metaclass persistent-class))
I’m just making something up here. Maybe another syntax would be needed for multi-dimensional indexing. My main point here is that it is relatively easy to create such extensions yourself and integrate them with the rest of Rucksack without having to resort to low-level hacks.
SCHEMAS
INTRO
Suppose we have some persistent objects that were created with the following class definition:
(defclass person ()
((name :initarg :name)
(age :initarg :age))
(:metaclass persistent-class))
Now we decide to change the class definition of PERSON to:
(defclass person ()
((name :initarg :name)
(birth-date :initarg :birth-date))
(:metaclass persistent-class))
THE PROBLEM
What should happen when we try to load one of the old person instances?
We can’t rely on UPDATE-INSTANCE-FOR-REDEFINED-CLASS, because as far as our Lisp implementation is concerned, the disk version of our persistent PERSON isn’t an instance of any class at all: it’s just some bytes in a file.
And when we load the object from disk, we can’t ALLOCATE an INSTANCE of the obsolete PERSON class, because we have no portable way of finding that obsolete class.
VERSIONS OF CLASS DEFINITIONS
Rucksack’s solution is to keep track of the schema of each persistent object. Each schema corresponds to a version of a class definition.
The most important elements of a schema are:
-
schema ID
-
class name
-
list of effective persistent slots
-
version number
All schemas are kept in a schema table. They’re indexed both by ID and by class name.
Whenever Rucksack saves a persistent object, it saves the schema id that corresponds to the object’s class.
When a persistent object must be loaded from disk, Rucksack loads the schema nr and finds the corresponding schema. If the schema has an old version number, Rucksack calls a generic function after calling ALLOCATE-INSTANCE for the current class version. The generic function is very similar to UPDATE-INSTANCE-FOR-REDEFINED-CLASS: it takes a list of added slots, a list of deleted slots and a property list containing the slot names and values for slots that were discarded and had values.
The default method for this function ignores the deleted slots, initializes added slots according to their initargs or initforms and initializes shared slots (that did not change) with the values that were saved on disk.
CREATING NEW SCHEMAS
When a class definition changes (e.g. because of DEFCLASS), this must be detected by Rucksack. (This can be done with the MOP by hooking into (RE)INITIALIZE-INSTANCE for persistent classes. We’re doing that anyway for keeping the class and slot indexes up to date.)
Rucksack analyzes the new class definition; if it’s different from the previous version, a new schema is added to the database. From that moment, when an instance of the redefined class is created it will be saved with the new schema number.


scale -
Variable in class net.parallaxed.bluejam.Scale
Subclasses of scale must have a representation of
jumps around the pitch wheel (see included documentation
on pitch definition), which allows the scale
to produce a terminal set in any key.
This function performs the selection, returning a
smaller population as set by newPopulationCount(int).}
Satisfies the implementation of IndividualSelector.
To allow this to be a heuristic, we must be able to override it's
SequenceParameters object (on construction), since
NoteTrees are cloned from this and need to have a reference to
it after cloning.


A vertex \(p_1\) that belongs to a polygon \(P\) is visible from vertex \(q_1\) that belongs to a polygon \(Q\) if the open segment going from \(p_1\) to \(q_1\) does not intersect with any other edge.
The Visibility Graph of a set of polygons \({P_1, P_2, ..., P_n}\) is the set of arcs that connects all the visible vertices.
The naive algorithm iterates each vertex of every polygon and it verifies its visibility against all other vertices. At each verification step the segment formed from one vertex to another should test that there is not any intersection with any other polygon. Thus the time complexity of this algorithm is \(O(n^3)\) where \(n\) is the total number of vertices. Other algorithms can compute the visibility graph in \(O(n^2log n)\) using a rotational sweep line to verify each vertex visibility. For simplicity reasons the \(O(n^3)\) algorithm will be used.
Returning to the robot path planning problem, remember that there are two types of representation spaces: a work space and a configuration space. In the work space the polygons represent the obstacles and the robot (represented by a polygon) is positioned somewhere in the arena (a plane) and plans to move to a goal position without colliding with any obstacle. However if the same problem is translated for the configuration space, the obstacles are the Minkownski Sum of the work-space obstacles and the robot polygon, being the later a point in space. In order to find the shortest path from the start robot position to the goal robot position it sufices to find the visibility graph between the obstacles and the two points (start and goal) each edge of a visibility graph is associated with a distance value that represents the cost of traveling from one point of the edge to another. Using Dijsktra's algorithm is possible to find the shortest path between the initial and the goal points and thus resolving the problem initially proposed.
This is an example that shows the visibility graph (red edges) of five polygons in white color and two points. Dijkstra algorithm is used to find the shortest path between the two points through the visibility graph edges (green path).


-
Why I’m Sick To Death Of Being A ‘Woman In Tech’
medium.com
When you work in an male-dominated industry and you happen to have breasts, you do get treated a little differently.
-
Will Silicon Valley Have Its NFL Moment?
online.wsj.com
A level of retrograde behavior and products, including sexist videogames, is proving remarkably resilient in the technology industry. When will tech ...
-
Digital Business Technologies Dominate Gartner 2014 Emerging Technologies ...
www.forbes.com
By Hung LeHong and Jackie Fenn Gartner, Inc. Imagine this: As you leave for work in the morning, your house automatically turns down the heat and ...
-
Google, Microsoft Expose Brazil's Favelas
online.wsj.com
Brazil's favelas, once known mainly for crime and disorder, have come to represent economic opportunity and Internet users. That's attracting Google ...
-
Yikes: Big Amazon Web Services reboot on the way Friday
gigaom.com
Many Amazon Web Services customers will soon be subjected to a reboot of their EC2 instances — but no one outside of AWS knows why.
-
Walter Isaacson on the women of ENIAC
fortune.com
The revolutionary computing machine had switches that needed resetting, a seemingly menial job. Today we call it programming.
-
Blow Minds. Teach STEM.
blowmindsteachstem.com
America isn't the sharpest bulb in the knife shed when it comes to math and science. We can change that with more excllent STEM teachers. Watch a ...
-
Venture Capitalist Sounds Alarm on Startup Investing
online.wsj.com
Silicon Valley may have taken on more risk than it can handle, according to prominent venture capitalist Bill Gurley, who cited potential cracks in ...
-
White House names Google’s Megan Smith the next Chief Technology Officer ...
www.washingtonpost.com
Former Twitter lawyer Alex Macgillivray will serve as deputy U.S. CTO.
-
Why Google Asks Everyone Applying For A Job The Same Exact Questions
www.businessinsider.com
Google hopes that informing employees about their subconscious biases will help them hire more fairly.
-
Gluten Free Chocolate Caramel Cake | Ivy's Garden
www.ivysgardenfood.com
Who’d ever think my son would inspire me to cook something gluten free? Well it was really for his girlfriend, who is on both a gluten free and vegan ...
-
Panamax Featured on the Popular Cloudcast Podcast
www.centurylinklabs.com
One of the most popular tech podcasts on the interwebs is The Cloudcast hosted by Aaron Delp and Brian Gracely. I was honored when they asked me to ...
-
16-year-old-girls take home top prize in Google Science Fair 2014
www.dailydot.com
This trio of 16-year-olds from Ireland found a revolutionary way to naturally boost crop yields.
-
TR3 liftoff in Markham
www.insightaas.com
The Toronto data centre space is hot, and getting hotter. One of North America's ten largest markets, the GTA is also one of the world's fastest ...
-
Obama Administration Pushes Paid Maternity Leave
www.huffingtonpost.com
The Obama administration wants to remind Americans that the United States is the only developed country without laws providing paid maternity leave. ...
-
My Little Operations: DevOps is Magic - DevOps.com
devops.com
DevOps is able to create something that doesn't actually exist anywhere - agility. That's magical.
-
Panda 4.1 -- Google's 27th Panda Update -- Is Rolling Out
searchengineland.com
Google has announced that the latest version of its Panda Update -- a filter designed to penalize "thin" or poor content from ranking well -- has ...
-
Urban Outfitters is now the largest vinyl retailer in the world
www.vox.com
Maybe it is the teens who are responsible for vinyl's unexpected revival
-
Why Shellshock Bug Is Way Nastier Than Heartbleed
www.eweek.com
NEWS ANALYSIS: Expert says that if your operating system is not patched automatically, install an update as soon as possible.
-
Cloud Foundry mastermind on where PaaS fits in hybrid cloud stacks | ...
siliconangle.com
The cloud way of doing things doesn’t come naturally for traditional enterprises. Processes must be reviewed, infrastructure replaced and workflows ...
-
'How The F**k Is This Still Happening?!?'
www.huffingtonpost.com
If you want to see everything that's wrong with the Miss America pageant summed up as brilliantly as possible, click on the "play" button and let ...
-
“Shellshock” Vulnerability & What You Need to Know - CenturyLink Cloud
www.centurylinkcloud.com
CenturyLink Cloud is the secure enterprise cloud hosting services powered by 11 global data centers. Ideal for business apps, IaaS, PaaS, and cloud ...
-
Ello | waxpancake
ello.co
Ello is a beautiful, simple, and ad-free social network. The Ello interface supports posting and private messaging. Ello allows users to share ...
-
Product Hunt
www.producthunt.com
Product Hunt is a curation of the best new products, every day. Discover the latest mobile apps, websites, and technology products that everyone's ...
-
Social Platform Hootsuite Adds $60M To Its Coffers, Buys Zeetl To ...
techcrunch.com
Hootsuite, a platform that lets businesses and individuals monitor and manage social media interactions across some 35 different social networks, is..
-
Deutsche Post DHL to Deliver Medicine via Drone
online.wsj.com
Deutsche Post DHL said it would use a drone to deliver medication to a German island in the North Sea, marking the first routine drone delivery to ...
-
Silicon Valley Income Gap Continues to Widen, New Study Shows
blogs.wsj.com
The income gap between a wealthy elite and the rest of Silicon Valley – an impetus for Google bus protests and housing strife – continues to widen, ...
-
Why India's Mars mission is so cheap - and thrilling
www.bbc.co.uk
India's Mangalyaan satellite is staggeringly cheap by Western standards - but it hopes to address some of the biggest questions on Mars, writes the ...
-
Rejoice! Your Full-Size Beauty Products Will Finally Make It Through ...
news.instyle.com
Gone are the days of sacrificing your jar of La Mer to the TSA! Get all the details here.


runtime.lfstack.pop (method)
7 uses
runtime (current package)
lfstack.go#L41: func (head *lfstack) pop() unsafe.Pointer {
mgc.go#L732: node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
mgcwork.go#L351: b = (*workbuf)(work.empty.pop())
mgcwork.go#L421: b := (*workbuf)(work.full.pop())
mspanset.go#L283: if s := (*spanSetBlock)(p.stack.pop()); s != nil {
proc.go#L2696: node := (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
proc.go#L2837: node = (*gcBgMarkWorkerNode)(gcBgMarkWorkerPool.pop())
The pages are generated with Golds v0.2.7-preview. (GOOS=darwin GOARCH=amd64)


--- layout: post title: Implementing the Store Locator Application Using ASP.NET MVC (Part 1) date: '2010-08-25T12:07:00.001+01:00' author: solrevdev tags: modified_time: '2010-08-25T12:07:53.569+01:00' blogger_id: tag:blogger.com,1999:blog-31446756.post-6708646871820837480 blogger_orig_url: http://www.solrevdev.com/2010/08/implementing-store-locator-application.html ---


Snookes1516.github.io
The Creative Writing Program at San Diego Mesa College offers a Creative Writing Certificate of Completion and range of classes for transfer credit and personal. University of California, San Diego Online Faculty Recruitment. San Diego State University, USA: Ausführliches Hochschulprofil, kostenloses Infomaterial, kompetente Beratung und Bewerbungshilfe. Member Spotlights Downtown San Diego Partnership. Overview of the admissions process for UC San Diego s MFA in Writing program. UCSD s Writing + Critical Expression Hub in the Teaching + Learning Commons Writing + Critical Expression. We work with UC San Diego student writers.
UC San Diego is located in the residential neighborhood of La Jolla of northern San Diego, California, bordered by the communities of La Jolla Shores, Torrey Pines. The Professional Certificate in Creative Writing is designed to provide individuals with the skills necessary to write in a variety of creative writing genres. Friday, August 10 2018. FOR SALE: Architect Lloyd Ruocco's Herrera Residence (1970) in El Cajon. MID-CENTURY MODERN ARCHITECTURE PERCHED HIGH ABOVE.
A NEW ASSIST ARRIVES MAY 2019! In the meantime, this website continues to display transferability information up to and including the 2016-17 academic.
June 23 – August 3, 2019 Clarion Science Fiction and Fantasy Writers’ Workshop at UC San Diego. Established in 1968, the Clarion Science Fiction and Fantasy. Copyediting Certificate UC San Diego Extension. John Pluecker Reading (UCSD Creative writing MFA) California changes can I make to my application after I submit it? . UC San Diego Literature. La Jolla Group Travel Hotels Marriott Meetings Events. AALHE Sample Rubrics - course1.winona.edu. Member Spotlight: The New Children’s Museum. The New Children’s Museum Awarded $249,739 IMLS Grant One of 133 projects focusing on creative positive community change.
The San Diego Chicken, also known as The Famous Chicken, the KGB Chicken or just The Chicken, is a sports mascot played by Ted Giannoulas. Information on the Young Writer s Camp, hosted each summer by the San Diego Area Writing Project at UC San Diego. Plan group travel for your team. Whether traveling with teammates or coworkers, Marriott International offers group travel deals and hotels designed for any gathering. Creative Writing. Bring your story to life with the help of our courses in areas such as fiction, children’s writing, non-fiction, stage and screenwriting, poetry. The University of California San Diego Extension is a premier online research university for community leaders and professionals. Join today.
UC San Diego Extension Continuing Education San Diego State University USA - college-contact.com. Creative Writing UC San Diego Extension. Writing Support - Teaching + Learning Commons. University of California, San Diego - Wikipedia. Our Department of English includes creative writing as part of its English major. Our english program includes film studies, literature theory and literature
Be sure to follow the san given in the MFA application guidelines and the SDF Writing A for creative to write compelling essays that show you UC San Diego. MFA Admission Overview - UCSD, Department of Literature. University Of California San Diego Mfa Creative Writing.
Lecturer Creative Writing (JPF01712) - UC San Diego
NOTE: If you arrived at this page from a redirect ( www.winona.edu/air or www.winona.edu/air/rubrics.htm ), please update your bookmark and any links.
Department of English - University of San Diego. Description: Campers design their own ultimate summer camp adventure at “the best camp ever!” This customized adventure is your child's dream
For detailed information, please enroll in the Writing Program Online Information Session. The program can be completed online in 9-12 months. The courses. Young Writers Camp (YWC) - San Diego Area Writing Project. We are your local, independent campus bookstore for official Triton gear, textbooks, supplies, gifts and technology. Serving UC San Diego students, faculty, staff. San Diego Mesa College Creative Writing Program.


{% extends "pagefetch/base.html" %} {% block content %}
Username: Password:
Don't have a login?
Forgot your login?


Room 404 shitty admin interface
Latest confessions
{% for entry in log %}
{{ entry.text }}
Delete
{% else %}
Unbelievable. No entries here so far
{% endfor %}


--- layout: page title: '' date: 2013-04-22 19:12:19.000000000 -04:00 type: page published: true status: publish categories: [] tags: [] meta: _edit_last: '2' cleanretina_sidebarlayout: right-sidebar _wp_page_template: default bwps_enable_ssl: '' Layout: 1c _css_code: ".me {\r\n padding: 0;\r\n margin: 0 25px 10px 0;\r\n}\r\n\r\nblockquote p {\r\n color: #3498db;\r\n}\r\n\r\n.sidebar-inter-content, #sidebar-entry {\r\n \ display: none;\r\n}" _post_restored_from: a:3:{s:20:"restored_revision_id";i:315;s:16:"restored_by_user";i:2;s:13:"restored_time";i:1377357537;} author: login<EMAIL_ADDRESS>email<EMAIL_ADDRESS>display_name: Aimee Knight first_name: Aimee last_name: Knight ---
I'm Aimee Knight, a former figure skater and software developer at SparkPost in Baltimore Maryland where I use Node.js and Angular to help build out email infrastructure for companies like Twitter, Facebook, and Pinterest. In 2014 I decided to go all out, and spent six months as a student in the fourth cohort of the Nashville Software School where I focused on JavaScript, Node.js, and Ruby on Rails.
Coming from a background in collegiate sports I'm highly driven. After my first degree, I spent a lot of time working with developers and in late 2012 my career path began to diverge. When a developer for my employer's site handed off their CMS to me saying "don't touch anything outside of this" my fate was sealed. My curiosity, coupled with increasing frustrations from the surmounting code changes we were always needing, led me on a path of no return. I started to stay up really late so I could work on the site while (hopefully) no one was looking. Within a few weeks I was hooked.
As a former professional figure skater I have a tremendous amount of energy and grit. Outside of work, I'm a panelist on the JavaScript Jabber and Angular Air podcasts, a co-organizer for CharmCityJS, and an avid runner. I'm a type A personality, and I’m not at peace, unless I have a set of challenges in front of me. As a former bootcamper, I also really enjoy mentoring current students, and helping out at Baltimore NodeSchool.


Sort By :
showing 50 results per page
| Transaction ID | Title | Description | Name Of the Merchant | Date | TimeStamp | Amount | Location |
|---|---|---|---|---|---|---|---|
| {{event.TransactionID}} | {{event.Title}} | {{event.Description}} | {{event.NameOfTheMerchant}} | {{event.Date}} | {{event.TimeStamp}} | {{event.Amount}} | {{event.location.coordinates}} |


Commit {{pageState.rev}}
Who:
{{commit.who}}
When:
{{commit.whenLocal}}
Message:
Change number {{changeNum+1}}
{{ change.open? "[-]" : "[+]" }}
From:
{{change.from}}
To:
{{change.to}}
Chunk {{chunkNum+1}}
{{ chunk.open? "[-]" : "[+]" }}
From
To
Line
{{line.fr}}
{{line.to}}
{{line.txt}}


TeamStream develops and markets infrastructure software that
enhances the ability of users and mobile users to access files from
any geographic location, then collaborate and share information via
the Internet.
Reviewer's Guidelines:
If you would like to evaluate TeamDrive, download our Reviewer's
Guidelines for step by step instructions.
Press Releases:
8.8.2002 - Xythos
Acquires TeamStream
8.20.2001 - TeamStream Launches TeamDrive 3.0 for Mobile Users.
01.26.01 - TeamStream Announces Universal Drive-Letter Access to Online Storage Services.
09.11.00 - IBackup to Offer TeamDrive to Its Customers Through Partnership with TeamStream
07.26.00 - TeamStream Releases New Online Storage Service Version of TeamDrive
06.28.00 - TeamStream Elects Chief Business Officer of SciClone to its Board
06.19.00 - TeamStream Oversubscribed Its Seed Round Funding


Rajinikanth Says Efforts Being Made To 'Saffronise' Him, But He Won't Fall For It
The actor clarified that while certain parts of the media were trying to insinuate that he would join the BJP, it was a decision that he needed to make.
by NewsroomActor-turned-political Rajinikanth said on Friday that the BJP had made efforts to to paint him “saffron” and that he, like an ancient Tamil poet Thiruvallur, would not fall for it. He was referring to the BJP releasing a photo of Tiruvalluvar in saffron clothes that created controversy.
PTI quoted Rajinikanth as saying, “No offer has been made (from BJP to join the party)... definitely not. Attempts are being made to paint me with BJP colour... trying to paint me with saffron like Thiruvalluvar was done with.. Neither Thiruvalluvar nor I will get trapped.”
For the latest news and more, follow HuffPost India on Twitter, Facebook, and subscribe to our newsletter.
The actor clarified that while certain parts of the media were trying to insinuate that he would join the BJP, it was a decision that he needed to make.
“Some people and media are trying to give an impression that I am a BJP man. This isn’t true. Any political party will be happy if anyone joins them. But it is on me to take a decision,” ANI quoted him as saying.
When asked about senior BJP leader Pon Radhakrishnan’s recent meeting with him and the former’s repeated assertions that the actor should join the party, Rajinikanth said no such has invitation has been made to him.
“No offer has been made (from BJP to join the party)..
definitely not,” he said.
“Attempts are being made to paint me with BJP colour..
trying to paint me with saffron like Thiruvalluvar was done with.. Neither Thiruvalluvar nor me will get trapped,” he said with a big laugh.
On November 1, the BJP’s Tamil Nadu unit on its Twitter handle had written a couplet from Thiruvalluvar’s classic “Thirukkural,” questioning the use of education if the Almighty was not worshipped.
Tagging the couplet, the saffron party targeted the Dravidar Kazhagam, DMK and the Left parties for allegedly deriding God and for berating believers and questioned “what is the use of their education.”
Also, the party had posted a picture of Thiruvalluvar in saffron robes with sacred ash on his forehead.
(With PTI inputs)


My readings
The News Connection
Read Articles
History
APatra has
Save
Clear history
Hallo title
Bla bli blub I'm an article
Connected pieces
Relation
Article title
Article description Article description Article description
Filters
All
Read
Unread
Similar
Opposite
Detailed
Broader View
Effect
Cause


| Jump to DART Documentation Main Index |
Provides a set of routines to generate a regular pattern of time windows. This module is only used for converting observation sequences files to netCDF format. If it stands the test of time, it will likely be used to create an assimilation schedule independent of the observation sequence file. Wouldn't that be nice ...
This namelist is read from the file input.nml. Namelists start with an ampersand '&' and terminate with a slash '/'. Character strings that contain a '/' must be enclosed in quotes to prevent them from prematurely terminating the namelist.
&schedule_nml first_bin_start = 1601, 1, 1, 0, 0, 0 first_bin_end = 2999, 1, 1, 0, 0, 0 last_bin_end = 2999, 1, 1, 0, 0, 0 bin_interval_days = 1000000 bin_interval_seconds = 0 max_num_bins = 1000 calendar = 'Gregorian' print_table = .true. /
Controls various aspects of filter. The inflation control variables are all dimensioned 2, the first value being for the prior inflation and the second being for the posterior inflation.
The default values will cause (pretty much) all possible observations to be put into one output file.
| Item | Type | Description |
|---|---|---|
| first_bin_start | integer, dimension(6) | Date/time specification for starting time of first bin. |
| first_bin_end | integer, dimension(6) | Date/time specification for ending time of first bin. Sets the bin width. |
| last_bin_end | integer, dimension(6) | Date/time specification for ending time of last bin. Sets the length of the overall time of the schedule. |
| bin_interval_days | integer | Sets the time between bins. Must be larger or equal to the bin width. |
| bin_interval_seconds | integer | Sets the time between bins. Must be larger or equal to the bin width. |
| max_num_bins | integer | Upper limit on the number of bins. |
| calendar | character(len=32) | String calendar type. Valid types are listed in the time_manager_mod file. |
| print_table | logical | If .TRUE., print out information about the schedule each time set_regular_schedule() is called. |
types_mod utilities_mod time_manager_mod
| use schedule_mod, only : | schedule_type |
| set_regular_schedule | |
| get_time_from_schedule | |
| get_schedule_length |
Namelist &schedule_mod_nml may be read from file input.nml.
type(schedule_type), intent(out) :: schedule
Uses the namelist information to compute and fill a schedule_type variable.
| schedule | Fills this derived type with the information needed to generate a series of regularly spaced time windows. |
type(time_type), intent(out) :: mytime or real(digits12), intent(out) :: mytime type(schedule_type), intent(in) :: schedule integer, intent(in) :: iepoch integer, optional, intent(in) :: edge
Returns either the leading or trailing time for the specified bin/epoch number for the given schedule. The time can be returned in one of two formats, depending on the variable type specified for the first argument: either a DART derived time_type, or a real of kind digits12 (defined in the types_mod).
| mytime | Return value with the leading or trailing edge time for the requested bin. There are two supported return formats, either as a standard DART time_type, or as a real value which will contain the number of days plus any fraction. |
| schedule | Schedule type to extract information from. |
| iepoch | The bin number, or epoch number, to return a time for. Unless edge is specified and requests the ending time, the time returned is the starting time for this bin. |
| edge | If specified, and if edge is larger than 1, the trailing edge time of the bin is returned. Any other value, or if this argument is not specified, returns the leading edge time of the bin. |
integer :: get_schedule_length type(schedule_type), intent(in) :: schedule
Return the total number of intervals/bins/epochs defined by this schedule.
| schedule | Return number of time intervals in this schedule. |
type schedule_type private integer :: num_bins integer :: current_bin logical :: last_bin integer :: calendar character(len=32) :: calendarstring type(time_type) :: binwidth type(time_type) :: bininterval type(time_type), pointer :: binstart( :) => NULL() type(time_type), pointer :: binend( :) => NULL() real(digits12), pointer :: epoch_start(:) => NULL() real(digits12), pointer :: epoch_end( :) => NULL() end type schedule_type
This type is used to define a schedule.
| filename | purpose |
|---|---|
| input.nml | to read the schedule_mod namelist |
| Routine | Message | Comment |
|---|---|---|
none at this time
Setting the schedule from the namelist values means you can only have a single schedule object in the entire program. We also need a subroutine to initialize a schedule type by giving explicit arguments.
N/A
DART software - Copyright UCAR. This open source software is provided by UCAR, "as is", without charge, subject to all terms of use at http://www.image.ucar.edu/DAReS/DART/DART_download


{% extends 'base.html' %} {% block content %}
亲，你不能删除此图片，请叫 {{ obj.user_name }} 帮你删除
You cannot delete this picture, Please contact {{ obj.user_name }} to do it


--- title: Console-tations Session 1 E3 2016 short: Out thoughts and diagnoses before E3 2016 category: nerd author: Tim comments: true published: true image: /images/console-tations-session1.jpg ---
Welcome to Console-tations, our nerd focused NRDPLS show! E3 is upon us so Chris and I, along with our junior console-tants, discuss how we're going to address all of the hype and mystery around the show.
Stay NRDy, my friends :)


Services
Web design and development
Sazu builds and takes care of your new website. We provide perfect cooperation with our customers and strive to the ease and comfort of the user. Sazu makes software that simplifies and clarifies the administration of your company. If you choose Sazu, you choose more time for the real work. We are improving every day in order to achieve new web projects and existing websites. In both designing and developing websites we're always looking for more values to your project as just that extra. Whether it's a simple website or an extensive shop or communty, we make it as user-friendly as we can.
Web strategy
Having a website is not enough to make a success of your Internet presence. In a web strategy we determine the goals you want to achieve and we will establish a plan whereby we address all the necessary Internet channels to work towards these goals. A solid web strategy is a mix of the use of social media, search engine optimization, marketing , email marketing and your website itself. This mix will lead you to your desired goals.
Email marketing
E- mail is a very important way of communication and not to imagine in today's professional life. Email marketing should be one of the pillars of your web strategy. A thoughtful email marketing strategy is great value for your readers and is a very effective element of your overall online strategy.
Portfolio
Frankensim
“Web-toy” is a new genre of brain stimulation and not one that we're completely at ease with.
http://frankensim.animade.tv/
Triondesign
Trionn Design’s one-page HTML5 website uses parallax scrolling to make it easier for users to navigate through the site. This responsive design uses attractive images to keep users engaged, and also incorporates some great CSS effects.
http://www.trionndesign.com/
Oakley
We have created this entertaining and eye catching site, combining parallax scrolling and amazing photography to showcase the new Airbrake MX goggles in a unique way.
http://moto.oakley.com/
Scroll for your health
Not only is this site stunning but it also provides useful information on your ‘5 a day’, encouraging visitors to eat more fruit. The site makes use of clever parallax scrolling for a bright, almost video-like feel.
http://www.shibui.me/web/scroll/index.html
Laura Baffari
Site made for Laura Baffari's illustration. Stunning interactive portfolio that uses horizontal scroll and touch swipe for smartphones and tablets. When entering the site you’ll see tiles displaying her work which can be scrolled through in any direction.
http://www.laurab.net/
Supremo
Data visualisations and interactive infographics are the most relevant part of this website, the type of content that earns you publicity and builds organic traffic through marketing led SEO.
https://www.supremo.tv/
My pizza oven
We have created this alluring site for Renato's pizza party business. Not only does this site make you hungry but the use of graphical elements throughout the page adds a nice touch.
http://mypizzaoven.nl/#data-home
News
About us
Sazu is an initiative of two students from Gent, engaged in
creating new websites, web
developement and graphic design.
Learn more about our team
Janne
Janne is 20 years young and has a passion for photography. She spends time in exploring Adobe programs, and has an unstoppable hunger for the Internet. Like Juan is Janne a motivated Graphic student in Artevelde Hogeschool in Ghent .
Juan
Juan has a Colombian roots. He studied for 3 years in Belgium . If you see him, it is likely that he is drawing or doing sports. Juan is a Graphic student at the Artevelde Hogeschool in Ghent.
Contact us
SAZU
Schaliënhoevedreef 20D
B-2800 Mechelen
+32 474421588


{include file="base/head" /}
后台首页
{include file="base/nav" /}
{include file="base/left" /}
主体内容加载中,请稍等...
{include file="base/script" /}


In this tutorial, we are going to learn about JavaScript (Vanilla JS) - for building incredible, powerful JavaScript applications.
Vanilla JS is a fast, lightweight, cross-platformframework for building incredible, powerful JavaScript applications.
Courses - 1 6 Lessons 1 Hour 12 Min
In et tempus dui, in porta dolor. Donec molestie a purus ut interdum. Donec quis felis dignissim, luctus libero ornare.
View Chapter DetailsCourses - 2 4 Lessons 32 Min
Malesuada fames ac turpis egesta mpor tempus tincidunt. Aliquam congue lacus ac tellus consectetur malesuada.
View Chapter DetailsCourses - 3 8 Lessons 10 Min
Aliquam pulvinar eros a dictur vitae diam imperdiet, ornare turpis vequet elit nec, imperdiet lectuna liquam qs.
View Chapter DetailsCourses - 4 10 Lessons 32 Min
In lobortis quam eu augue spendisse imperdiet nec orci ipsum, tempus pharetra posuere imperdiet, lacinia a nisl.
View Chapter DetailsCreate beautiful website with this Geeks UI template. Get started building a site today.
Lessons
Students
Learning Hours
12+ million people are already learning on Geeks
The generated lorem Ipsum is therefore always free from repetition, injected humour, or words etc generate lorem Ipsum which looks racteristic reasonable.
Lorem ipsum dolor sit amet, consectetur adipi scing elit. Sed vel felis imperdiet, lacinia metus malesuada diamamus rutrum turpis leo, id tincidunt magna sodales.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. In mattis non accumsan in, tempor dictum neque.
Effective learning starts with assessment. Learning a new skill is hard work—Signal makes it easier.


CheckpointManager
Deletes old checkpoints.
tf.compat.v1.train.CheckpointManager
tf.compat.v2.train.CheckpointManager
import tensorflow as tf checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model) manager = tf.contrib.checkpoint.CheckpointManager( checkpoint, directory="/tmp/model", max_to_keep=5) status = checkpoint.restore(manager.latest_checkpoint) while True: # train manager.save()
CheckpointManager
preserves its own state across instantiations (see the
__init__
documentation for details). Only one should be active in a
particular directory at a time.
__init__
__init__( checkpoint, directory, max_to_keep, keep_checkpoint_every_n_hours=None, checkpoint_name='ckpt' )
Configure a CheckpointManager
for use in directory
.
If a CheckpointManager
was previously used in directory
, its
state will be restored. This includes the list of managed checkpoints and
the timestamp bookkeeping necessary to support
keep_checkpoint_every_n_hours
. The behavior of the new CheckpointManager
will be the same as the previous CheckpointManager
, including cleaning up
existing checkpoints if appropriate.
Checkpoints are only considered for deletion just after a new checkpoint has
been added. At that point, max_to_keep
checkpoints will remain in an
"active set". Once a checkpoint is preserved by
keep_checkpoint_every_n_hours
it will not be deleted by this
CheckpointManager
or any future CheckpointManager
instantiated in
directory
(regardless of the new setting of
keep_checkpoint_every_n_hours
). The max_to_keep
checkpoints in the
active set may be deleted by this CheckpointManager
or a future
CheckpointManager
instantiated in directory
(subject to its
max_to_keep
and keep_checkpoint_every_n_hours
settings).
checkpoint
: The tf.train.Checkpoint
instance to save and manage
checkpoints for.directory
: The path to a directory in which to write checkpoints. A
special file named "checkpoint" is also written to this directory (in a
human-readable text format) which contains the state of the
CheckpointManager
.max_to_keep
: An integer, the number of checkpoints to keep. Unless
preserved by keep_checkpoint_every_n_hours
, checkpoints will be
deleted from the active set, oldest first, until only max_to_keep
checkpoints remain. If None
, no checkpoints are deleted and everything
stays in the active set. Note that max_to_keep=None
will keep all
checkpoint paths in memory and in the checkpoint state protocol buffer
on disk.keep_checkpoint_every_n_hours
: Upon removal from the active set, a
checkpoint will be preserved if it has been at least
keep_checkpoint_every_n_hours
since the last preserved checkpoint. The
default setting of None
does not preserve any checkpoints in this way.checkpoint_name
: Custom name for the checkpoint file.ValueError
: If max_to_keep
is not a positive integer.checkpoints
A list of managed checkpoints.
Note that checkpoints saved due to keep_checkpoint_every_n_hours
will not
show up in this list (to avoid ever-growing filename lists).
A list of filenames, sorted from oldest to newest.
latest_checkpoint
The prefix of the most recent checkpoint in directory
.
Equivalent to tf.train.latest_checkpoint(directory)
where directory
is
the constructor argument to CheckpointManager
.
Suitable for passing to tf.train.Checkpoint.restore
to resume training.
The checkpoint prefix. If there are no checkpoints, returns None
.
save
save(checkpoint_number=None)
Creates a new checkpoint and manages it.
checkpoint_number
: An optional integer, or an integer-dtype Variable
or
Tensor
, used to number the checkpoint. If None
(default),
checkpoints are numbered using checkpoint.save_counter
. Even if
checkpoint_number
is provided, save_counter
is still incremented. A
user-provided checkpoint_number
is not incremented even if it is a
Variable
.The path to the new checkpoint. It is also recorded in the checkpoints
and latest_checkpoint
properties.


Field¶
// Specification of a Single View
{
...,
"encoding": { // Encoding
...: {
"field": ..., // Field
"type": "quantitative",
...
},
...
},
...
}
A field definition of an encoding channel must include a field
in order to map an encoding channel to a data field. The sort field definition can also have the field
property to sort the encoded field by another field as well.
The field
property can be one of:
1) A string representing the data field.
For example, we can set field
to "precipitation"
to map it to x
position.
Valid JavaScript object access paths using either dot (e.g., foo.bar
) or bracket with quotes (e.g., foo['bar']
) notations can be used in field
to perform nested object lookups. If field names contain dots or brackets but are not nested, use \\
to escape dots and brackets. For example, if the field name is a.b
, use a\\.b
. Similarly, if the field name is a[0]
, use a\\[0\\]
.
Further note that in JSON, you have to escape backslashes. Hence, a single backslash (\
) is escaped as \\\\
in JSON. You also need to escape quotes (\"
) and use special escape characters for newlines (\n
), carriage returns (\r
), and tabs (\t
).
2) An object defining iterated values from the repeat
operator
For example, we can set field
of x
channel to {"repeat": "column"}
to create a histogram of different fields.
See the repeat
page for more information about the repeat
operator and more examples.


lidbox
| Notebook as HTML | Description |
|---|---|
common-voice-small |
Classifying 4 languages from the Mozilla Common Voice dataset |
common-voice-augmenting |
Repeating example 1 with speech data augmentation |
common-voice-embeddings |
Using the trained model from example 2 as a language vector extractor for a back-end classifier |
common-voice-angular-lstm |
Training a language vector model with a dedicated, angular proximity loss function to maximize distance between vectors from different languages |


Our goal is to work through examples that demonstrate how to explore, process and manipulate SAM and BAM files with the samtools
software package.
For future reference, use the samtools documentation.
Follow these steps:
cd ~
# optional. you may already have a src directory
mkdir src
cd ~/src
git clone https://github.com/samtools/htslib
git clone https://github.com/samtools/samtools
cd samtools
make
cp samtools ~/bin
Create a new directory from your home directory called “samtools-demo”.
cd ~
mkdir samtools-demo
Navigate into that directory.
cd samtools-demo
Download the example gzipped SAM file I have provided.
curl https://s3.amazonaws.com/samtools-tutorial/sample.sam.gz > sample.sam.gz
gzip -d sample.sam.gz
To bring up the help, just type
samtools
As you can see, there are multiple “subcommands” and for samtools to work you must tell it which subcommand you want to use. Examples:
samtools view
samtools sort
samtools depth
To do anything meaningful with alignment data from BWA or other aligners (which produce text-based SAM output), we need to first convert the SAM to its binary counterpart, BAM format. The binary format is much easier for computer programs to work with. However, it is consequently very difficult for humans to read. More on that later.
To convert SAM to BAM, we use the samtools view
command. We must specify that our input is in SAM format (by default it expects BAM) using the -S option. We must also say that we want the output to be BAM (by default it produces BAM) with the -b option. Samtools follows the UNIX convention of sending its output to the UNIX STDOUT, so we need to use a redirect operator (“>”) to create a BAM file from the output.
samtools view -S -b sample.sam > sample.bam
Now, we can use the samtools view command to convert the BAM to SAM so we mere mortals can read it.
samtools view sample.bam | head
When you align FASTQ files with all current sequence aligners, the alignments produced are in random order with respect to their position in the reference genome. In other words, the BAM file is in the order that the sequences occurred in the input FASTQ files.
samtools view sample.bam | head
Doing anything meaningful such as calling variants or visualizing alignments in IGV) requires that the BAM is further manipulated. It must be sorted such that the alignments occur in “genome order”. That is, ordered positionally based upon their alignment coordinates on each chromosome.
samtools sort sample.bam -o sample.sorted.bam
Now let’s check the order:
samtools view sample.sorted.bam | head
Notice anything different about the coordinates of the alignments?
Indexing a genome sorted BAM file allows one to quickly extract alignments overlapping particular genomic regions. Moreover, indexing is required by genome viewers such as IGV so that the viewers can quickly display alignments in each genomic region to which you navigate.
samtools index sample.sorted.bam
This will create an additional “index” file. List (ls
) the contents of the current directory and look for the new index file.
ls
Now, let’s exploit the index to extract alignments from the 33rd megabase of chromosome 1. To do this, we use the samtools view
command, which we will give proper treatment in the next section. For now, just do it without understanding. No really. Do it.
samtools view sample.sorted.bam 1:33000000-34000000
How many alignments are there in this region?
samtools view sample.sorted.bam 1:33000000-34000000 | wc -l
The samtools view
command is the most versatile tool in the samtools package. It’s main function, not surprisingly, is to allow you to convert the binary (i.e., easy for the computer to read and process) alignments in the BAM file view to text-based SAM alignments that are easy for humans to read and process.
Let us start by inspecting the first five alignments in our BAM in detail.
samtools view sample.sorted.bam | head -n 5
Let us start by inspecting the first five alignments in our BAM in detail.
samtools view -X sample.sorted.bam | head -n 5
You can use the detailed help to get a better sense of what each character in the human “readable” FLAG means. See section 6 of the Notes.
samtools view -?
samtools view sample.sorted.bam | wc -l
The “header” in a BAM file records important information regarding the reference genome to which the reads were aligned, as well as other information about how the BAM has been processed. One can ask the view
command to report solely the header by using the -H
option.
samtools view -H sample.sorted.bam
As we discussed earlier, the FLAG field in the BAM format encodes several key pieces of information regarding how an alignment aligned to the reference genome. We can exploit this information to isolate specific types of alignments that we want to use in our analysis.
For example, we often want to call variants solely from paired-end sequences that aligned “properly” to the reference genome. Why?
To ask the view
command to report solely “proper pairs” we use the -f
option and ask for alignments where the second bit is true (proper pair is true).
samtools view -f 0x2 sample.sorted.bam
How many properly paired alignments are there?
samtools view -f 0x2 sample.sorted.bam | wc -l
Now, let’s ask for alignments that are NOT properly paired. To do this, we use the -F
option (note the capitalization to denote “opposite”).
samtools view -F 0x2 sample.sorted.bam
How many improperly paired alignments are there?
samtools view -F 0x2 sample.sorted.bam | wc -l
Does everything add up?
There are many other options for the view
command. This is merely meant to be an appetizer. Please look through the help, as well as visit the samtools documentation site.


The professor of divination wants to introduce a certain phenomenon that occurred in the past few decades.
She begins her lesson with a riddle and wants you to properly identify the name of the phenomenon.
With a wave of her wand, the chalk flits across the board, and a message soon appears:
One day, the wizard of Oz was walking down the street and recognised a witch in the crowd. “Mis,” he said, “would you like to attend an Event with me?”


All About My Niece
Fun Facts about my Niece
Her name is Rainy
She
loves
to dance.
She is an
expert
climber.
Change the background theme using the buttons below!
Light
Dark
Original


Turquoise
chess
●
connected
|
●
ChessLink |
v0.0.1
New
❙◀
◀
◼
▶
▶❙
FEN:
↵
ChessLink board:
Import position
❙◀
◀
◼
▶
▶❙
❙◀
◀
◼
▶
▶❙


zecpaperwallet
Move around your mouse or type random characters into the box below until the bar is full.
Collected Entropy:
Generating wallet. Please wait…


Sara Ali Khan's latest travel photos will make you pack your bags and go for a vacay
by TIMESOFINDIA.COMSara Ali Khan is currently holidaying in New York along with her friend and her pictures are screaming out that she is having the best time of her life with her girl gang. The 'Simmba' actress who had completed her studies there is not only partying hard but also is working hard to maintain her gym routine.
She has been sharing some stunning photos visiting the local cafes, pubs, pizza joints and much more. Just a few minutes ago she shared yet other pics wandering on the streets in NYC.  She was also seen wearing black wayfarer sunglasses and earmuffs. The actress was carrying a small sling bag with her.
Check out the photos:
On the work front, Sara will be next seen in Imtiaz Ali’s ‘Aaj Kal’, co-starring Kartik Aaryan that will hit the theatre screen in February 2020. Later, she will be back in May with the ‘Coolie No. 1’ remake, co-starring Varun Dhawan in the lead.


new Validation()
Validation class
This is the interface class for user enties validation
- Source:
Returns:
Session Object
Methods
-
_isAffiliation(affiliation)
-
Checks if the given affiliation has a valid syntax. The affiliation should be between 2 and 20 digits, underscore, hyphen, apostrophe and dots are allowed. First letter can be only character.
Parameters:
Name Type Description affiliation
String affiliation value to be validated - Source:
-
_isEmail(email)
-
Checks if the given text is a valid email address
Parameters:
Name Type Description email
String email to be validated - Source:
-
_isEmpty(text)
-
Checks if the given text is not empty
Parameters:
Name Type Description text
String to be checked - Source:
-
_isEmpty(username)
-
Checks if the given text is a valid username The username must be between 5 and 15 characters, dot and underscore are allowed, the first letter should be number or character.
Parameters:
Name Type Description username
String to be checked - Source:
-
_isKeyName(keyDescription)
-
Checks if the given public key description name has a valid syntax. The public key description should be from 3 to 15 digits long. The first letter has to be a character. Only alphanumeric characters are allowed.
Parameters:
Name Type Description keyDescription
String public key description value to be validated - Source:
-
_isKeyValue(keyValue)
-
Checks if the given public key value has a valid syntax. Client side validation is just checking for valid length. The public key length should be between 100 and 500 digits.
Parameters:
Name Type Description keyValue
String public key value value to be validated - Source:
-
_isName(name)
-
Checks if the given text is a human name or surname. Acceptable names include compound names with a hyphen or a space in them.
Parameters:
Name Type Description name
String string name to be checked - Source:
-
_isPassphrase(phrase)
-
Checks if the given password phrase is strong enough. Password must be at least 4 characters, no more than 8 characters, and must include at least one lower case letter, and one numeric digit.
Parameters:
Name Type Description phrase
String password phrase to be validated - Source:
-
_isPassword(pwd)
-
Checks if the given password is strong enough. Password must be between 4 and 8 digits long and include at least one numeric digit.
Parameters:
Name Type Description pwd
String password string to be validated - Source:
-
_isValidPublicKeyFileExtension(extension)
-
Checks if the given public file extension is a valid one.
Parameters:
Name Type Description extension
String public key file extension to be validated - Source:
-
_isValidPublicKeyFileSize(file_size)
-
Checks if the given public file size has a valid length.
Parameters:
Name Type Description file_size
String public key file size to be validated - Source:


|
Check-in to get issued your first attendance claim. This will be recorded with your DID* *DID = Decentralised Identifier |
If you have collected the required credentials you can claim your reward. We require your name and email in order to issue you your reward certificate. Configure these values in your uPort App. |


Roles
Innocents
Detectives
Traitors
Jesters
Independents
Monsters
Resources
Tutorials
Developer API
Discord


A website for our chemistry class. It can do certain chem calculations. Learning chemistry is fun, try this website.
This is a canvas show grade with amaination system. You need to be able to log into your canvas in order to use this application.  By the way, you need to install the application first using a chrome extention called "tempermonkey".


>>> # one comment
... print 'Hello World!' # another comment
Hello World!
There are special comments called documentation strings, or "doc strings" for short. You can add a "comment" at the beginning of a module, class, or function string that serves as a doc string, a feature familiar to Java programmers:
def foo():
"This is a doc string."
return True
Unlike regular comments, however, doc strings can be accessed at runtime and be used to automatically generate documentation.


A few years ago I was prescribed Welbutrin for depression. Apparently I developed psychotic tendencies which could be attributed to the Welbutrin, so my psychiatrist prescribed for me Risperdol, an anti-psychotic. Why he didn't just take me off Welbutrin and prescribe another anti-depressant is beyond me.
One night I dropped four hits of LSD and proceeded to have a very intense trip. About 5 or 6 hours later it was time for me to take my usual dose of Risperdol. I was still tripping very hard, and was not expecting to come down for another 6 hours, but surprisingly enough, I was completely down within half an hour. I should have realized that this was going to happen as Risperdol is in the same class as Thorazine which is used to end bad trips in the hospital.
Some interesting side notes about Risperdol. In short, I hated this drug. It made me feel disconnected from the world.  I didn't seem to care about anything. I enjoyed spending my time watching tv, and settled into a mundane existence. After taking the drug for some time I began periodically skipping doses. This was very pleasurable as I would begin to FEEL again, and my emotions were intensified by the previous numbness that seemed to envelope me. Overall I think Risperdol did more damage than good. Luckily enough, I have been free of all prescription drugs for over three years, and even stopped using psychedelics because I felt that I wasn't in the right state to use them and realized that I had begun to abuse them. It is only recently that I've felt confident enough to be able to use psychedelics in moderation and gain the best from them.
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.


RCom shares rally 6% to hit upper circuit on asset sale buzz
RCom's secured debt is estimated to be around Rs 33,000 crore.
by PTIShares of Reliance Communications hit their upper circuit on Monday, rising over 6 per cent, amid reports that Bharti Airtel, Reliance Industries and three others may bid for the assets of debt-ridden company. On the BSE, shares of the company rose 4.55 per cent to 69 paise apiece.
Meanwhile, Bharti Airtel was trading 3.81 per cent higher at Rs 437.05 and Reliance Industries (RIL) was up 1.04 per cent at Rs 1,562.45 on the BSE.
Bharti Airtel, RIL and three others are likely to bid for the assets of debt-ridden Reliance Communications on Monday, according to sources close to the development.
"Varde Partners, Bharti Airtel and Reliance Industries, UV Asset Reconstruction Company (UVARCL) are among the main contenders for RCom assets," sources said.
The last date to submit bids will end on Monday and RCom committee of creditors will also meet on the same day to open bids.
RCom's secured debt is estimated to be around Rs 33,000 crore. Lenders have submitted claims of around Rs 49,000 crore in August.
As per an National Company Law Tribunal (NCLT) order, resolution professional has to complete the insolvency process by 10 January, 2020.
RCom in the past had tried to sell assets to various companies, including Reliance Jio, to clear debt but the deals did not crystallise.