Kingdom of Kano
From Wikipedia, the free encyclopedia
Jump to: navigation, search
Sarautar Kano
Ad Daulat Al Kano
Tribal Kingdom
Busar Bagauda
Drum of Bagauda
Capital Dala
(999- ???)
Languages Hausa (official), Arabic
Religion Hausa Animism
Government Absolute Monarchy
List of Kings of Kano
 - 999 Bagauda (first)
 - 1349 Ali Yaji Dan Tsamiya (last)
Grand Vizier
 - ???–???? shamaki (first)
 - ?????? (last)
Legislature Taran Kano
 - Upper house House of Nine
 - Founded ???? 999
 - Fall of the Maghira Dynasty 800 Circa
 - Rise of the Cult of Tsumbubura 1100
 - Battle of Santolo 1349
 - Fall of the Cult of Tsumbubbura ??? 1340
Currency Dirham, Salt, Gold, Cowries
Today part of
Part of a series on the
History of Northern Nigeria
Northern Nigeria
The Kingdom of Kano was a Hausa kingdom in the north of what is now Northern Nigeria that dates back before 1000 AD, and lasted until the proclamation of the Sultanate of Kano by King Ali Yaji Dan Tsamiya in 1349. The kingdom was then replaced by the Sultanate of Kano, under the suzerainty of a Muslim Sultan The capital is now the modern city of Kano in Kano State.[1]
Kano lies to the north of the Jos Plateau, located in the Sudanian Savanna region that stretches across the south of the Sahel. The city lies near where the Kano and Challawa rivers flowing from the southwest converge to form the Hadejia River, which eventually flows into Lake Chad to the east. The climate is hot all year round. Rainfall is variable, ranging from 350mm to 1,300mm annually with the mean around 950mm, almost all falling during June–September period. Traditionally agriculture was based on lifting water to irrigate small parcels of land along river channels in the dry season, known as the Shadouf system. At the time when the kingdom was flourishing, tree cover would have been more extensive and the soil less degraded than it is today.[2]
Early history[edit]
Our knowledge of the early history of Kano comes largely from the Kano Chronicle, a compilation of oral tradition and some older documents composed in the nineteenth century, as well as more recently conducted archaeology.
In the 7th century, Dala Hill, a hill in Kano, was the site of a community that engaged in iron-working. It is unknown whether these were Hausa people or speakers of Niger–Congo languages.[3] Some sources say they were Hausa speaking hunter/gatherers known as Abagayawa who migrated from Gaya.[1] The Arab geographer al-Yaqubi, writing in 872/873 CE (AH 259), describes a kingdom called "HBShH" with a city named "ThBYR" ruled by a king called "MRH" (none of these words are vocalized, so their actual pronunciation can vary), located between the Niger Bend and the Kingdom of Kanem.[4] If the kingdom's name is vocalized as "Habasha" it would correspond with other Arabic language texts that also appear to refer to the Hausa, and would be the earliest reference to the Hausa region.
Kano was originally known as Dala, after the hill, and was referred to as such as late as the end of the 15th century and the beginning of the 16th by Bornoan sources.[5] The Kano Chronicle identifies Barbushe, a priest of a Dalla Hill spirit, as the city's first settler.[6] (Elizabeth Isichei notes that the description of Barbushe is similar to those of Sao people.)[7] According to the Kano Chronicle, Bagauda, a grandson of the mythical hero Bayajidda,became the first Hausa king of Kano in 999, reigning until 1063.[8][9][10][11][12] His grandson Gijimasu (1095–1134), the third king, began building city walls at the foot of Dalla Hill, and Gijimasu's son, Tsaraki (1136–1194), the fifth king, completed them during his reign.[11] The Bagauda family steadily extended the kingdom through conquest of nearby communities. They established numerous sub-rulers, with titles starting with "Dan", of which the most important was "Dan Iya".[1][13]
Ali Yaji[edit]
Ali Yaji (1349–85)presided over the introduction of the Abrahamic religions in Kano, he brought in holy men from Wangara, presumably Mali. He extended Kano's reach and launched an unsuccessful expedition into the Kwarafa region.[14] He became the Last king of Kano when in the 1350s, after conquering Rano and Santolo he made Islam the state religion and proclaimed an end to the Kingdom, Kano from then on became an Islamic sultanate and its leaders took on the Title of Sultan.
See also[edit]
 1. ^ a b c Ibrahim Ado-Kurawa. "Brief History of Kano 999 to 2003". Kano State Government. Retrieved 2010-09-12.
 2. ^ Kabiru Ahmed. "The Kano Physical Environment". Kano State Government. Retrieved 2010-09-12.
 4. ^ al-Ya'qubi, "Tarikh" in Nehemiah Levtzion and J. F. P. Hopkins, transl, Corpus of Early Arabic sources for West African History (Cambridge University Press, 1981), p. 21.
 6. ^ "Kano Chronicle" ed. H. R. Palmer in Journal of the Royal Anthropological Institute of Great Britain and Ireland 38 (1908) p. 63
 8. ^ "Kano Chronicle" ed. H. R. Palmer,pp. 64-65.
 10. ^ "Kano". Britannica Online. Encyclopædia Britannica, Inc.
 12. ^ H. R. Palmer, ed. and trans. "The Kano Chronicle" Journal of the Royal Anthropological Institute of Great Britain and Ireland 38 (1908), p. 65.
 13. ^ "Kano Chronicle" ed. Palmer, pp. 66, 67.
 14. ^ "Kano Chronicle," ed. Palmer, pp. 70-72.


Rootstrap Blog
How to Use Counter Caches in Rails (Example)
Counter caches are great until you get 20,000 people following the same influencer and the counter cache on that person locks the whole database.
The goal of this post is to go through the basics of counter caches explaining possible alternatives to overcome this.
What are counter caches for?
Counter caches were created to cache the counts of associated records.
Imagine we are developing a social media application where we have influencers and fans:
Everytime we display an influencer in the list we want to show how many followers he has.
The naive approach to achieve this is doing a count of the associated fan records for each influencer.
While this might be enough if we are rendering only one influencer, it definitely does not scale well if we are going to render a list of many influencers, since it's going to trigger a select count query for each influencer.
In the logs we get:
… and goes on for each influencer…
That's when counter caches gain importance. Counter caches are a built in Rails feature that allows you to track the associated records count by doing almost nothing. It only requires you to add a new integer column in the influencers table and let the associated model know that it has to update that column every time a records gets created or destroyed (or is no longer referencing the influencer).
To use Rails counter caches you need to create a migration to add a new integer column to the associated model:
Let the FanInfluencer model know it has to update the counter cache in the influencer model:
Reset the counters for existing records with:
And then you are ready to use the new column like you would with any other attribute:
Using the new counter cache the db will execute only one query that will select the influencers to be rendered, since fans_count is now just a column on the influencer and no counts or joins with other tables are needed.
(Should you need more complex counter caches, consider using Counter culture gem that works around some deficiencies in Rails original counter caches.)
So… what's the problem?
Counter Caches have a fairly simple implementation using callbacks to keep this column updated. Every time a fan influencer record is created, updated, or destroyed, the counter cache on the corresponding influencer needs to get updated. This might make these type of operations slower. If that's a cost you can take, go ahead. But consider the following situation:
Imagine a very famous influencer has been advertised and suddenly all of our users click on 'Follow'. Every 'Follow' action on that influencer creates a fanInfluencer record, which will end in the db trying to execute many update queries to the counter cache of the influencer around the same time, locking up that db row and making our users requests time out. Ugh…
First solution. Use an SQL alternative to dynamically calculate the count without falling into the n+1 problem raised before introducing the counter caches.
We need to add the following scope on the influencer model:
When we load the influencers to render we need to use the new scope:
And then we just call fans_count for a particular influencer to get the counter.
In the logs we get:
This solution is slower than having the counter cache when rendering the influencer list since the latter one only has to select attributes of the same table. However, using this method you don't need to keep any counter cache column updated, making create/destroy/update actions on the fan_influencer table simpler since they don't trigger any callback afterwards. The db lock problem will go away.
So, this SQL alternative could be appropriate for you if:
 - You have many create/destroy/update actions on the fan_influencer table in comparison to requesting the influencers fans count.
 - Your app is prone to facing situations like the mentioned above, where the counter cache of a single record could get updated more times in a small period of time than it can handle.
Comparing the three approaches
We measured the time it took to request all the influencers each with his fans count using the three different approaches. In the db there were only 10 influencers and 1,000 fans, all the fans following all the influencers. The times are calculated as the average Active Record time of 5 runs.
Method #1: Using naive approach (fans.count)
Method #2: Using counter cache column
Method #3: Using SQL dynamic count
Second solution. Store the changes of the counter in a buffer in a faster storage first (like redis or Memcached) to later update the real value in the database.
After a fan_influencer record has been created or destroyed, the value in the redis cache for the influencer key is increased or decreased by one. After a couple of seconds, the count value for the redis key is added (or subtracted) to the counter cache in the db, and reset to 0.
A good idea is to also use a recalculation job once in a while, to make sure the counters are updated with the real count value, compensating for transient errors that may cause the deferred counters to drift from the actual value.
There are many gems that help you achieve this if you don't want to implement it yourself.
In this post it was used Wanelo gem to enqueue the jobs for me, but since it hasn't been committed to since Oct 7, 2016 you might want to implement that part yourself.
Next it's explained how to achieve this using that gem and assuming you have redis and a background worker installed. In this case it was used Delayed Jobs as the worker but you will see that it is very simple to modify the solution to use another one.
Start by configuring the gem with:
Let the fanInfluencer model know how to use the counter cache:
Create a method in the influencer to update the count to the real value
And here is where the fun part begins.
The gem adds a callback after a FanInfluencer record gets created or destroyed that triggers the enqueue method in the class called CCWorker as we configured before. So we need to create this class:
As you might have noticed, the enqueue method decides which Enqueuer class to delegate the execution to depending on the option 'cache'. Since the gem is the one that makes the calls to this method with the right arguments, we just need to implement those two modes knowing that we will receive two calls after a fanInfluencer has been created or destroyed: one for recalculation and one for deffered.
We can begin by creating the parent Enqueuer class, that decides if the job needs to be enqueued or if it's already pending.
We will now implement the deferred mode, for which we will define the 'execute' method that will be called by the asyncrhonous worker once the time is up. For this mode the gem comes with a counter class that does the buffering and updating part for us, so we just need to use it.
For the recalculation mode, we will call the method that we defined in the influencer at the begging, to reset the counter agains the real count. The name of this method comes in the options so we need to invoke it.
And that's it. Now we can try creating and destroying fans and influencers and we will see how their count changes after the number of seconds that we picked, and a recalculation job is enqueued for later.
To test it, we can create 100 fans that would follow Taylor Swift.
For each fanInfluencer created we can see logs like the following, where after the fanInfluencer record is created, two delayed jobs are inserted:
You can see in the redis cli console how the new keys are created, with the values 100 in the key for the buffer managed by the gem, and a 1 in the other two keys that mark the corresponding jobs as enqueued so they won't be enqueued again. In this case '104' that you see in the key name corresponds to the id of the influencer created.
After the 20 seconds (or whatever you configured for the env var) have passed, if you turned on your worker, we can see Taylor Swifts fans count has been raised.
To test the recalculation mode, we can update the fans count to any other incorrect value and wait until the recalculation method fixes it.
Notice that when using Delayed Jobs, since two jobs need to be enqueued (inserted into the db) after a fanInfluencer has been created, the 'follow' action is in total slower than before when no other 'follow' action is being performed at the same time. However, under big load the row contention problem does not happen, making this approach more efficient in that case.
Since the solution for the enqueuer does not depend on the influencer model, you can reuse it for any other counter cache that you may want to optimize, just by configuring the counter cache in the associated class and defining the recalculation method.
1 Comment
 1. Felipe
 July 9, 2021 - 1:53 am
 Amazing, I implemented a similar solution in my company and now I'm writing a Gem to do it!
 Does this code has any license attached to it?
Leave a Reply


Signs of a wolverine
The wolverine moves in a unique manner, which leaves behind tracks that stand out because of their orientation and large size.
Wolverine traces. Wolverine traces. Photo: Risto Sauso
Wolverine tracks
The wolverine moves in a unique manner, which leaves behind tracks that stand out because of their shape and large size. The wolverine moves either by jumping, which creates paired tracks, or by galloping, which leaves a slanted line where the impressions appear in threes. The wolverine's paw print features five toes, unlike lynx and wolf tracks in which only four toes can be seen. The wolverine's paw print is triangular and tapers towards the heel. The impressions left by the toes are clearly visible as they curve on the front of the paw's central pad in a sort of semi-circle.
The wolverine's foreleg is larger than its hindleg. Including the heel, the paw print of the foreleg is 12–16 cm long. The wolverine's hindleg leaves a print that is 8–10 cm long. The wolverine is a partial plantigrade, which is why the carpal pads of its forelegs leave a distinct impression in the snow if it isn't too deep and it isn't light frost snow. In these kinds of snow conditions the rear parts of the carpal pads are usually not distinctly visible and the paw print is little more than an outline of the paw.
The wolverine has large legs relative to its size and weight that allow it to move quickly and with little effort even in deep, sinking snow. You rarely see a wolverine wade in the snow as our other large carnivores are sometimes forced to do when the snow is particularly deep and soft. In these kinds of conditions the wolverine will walk, which it never really does otherwise. The wolverine's walking tracks are large and its steps are a lot shorter than those of lynxes or wolves. The wolverine will try to revert back to jumping or galloping as soon as possible.
The wolverine's preferred mode of locomotion is a calm gallop. This results in tracks where the paw prints are grouped in threes or fours. A galloping wolverine's step is between 80 and 120 cm long. In soft snow the wolverine usually moves by jumping, which is typical for animals in the weasel family. The step of a jumping wolverine's step is 60–100 cm long. The wolverine varies its movements quite a bit and it may suddenly go from galloping to jumping or the other way around, depending on the situation.
The wolverine is known to embark on long, determined treks. It is a curious animal that may change its course when it comes across an interesting land mark, such as a large boulder. Sometimes a wolverine's tracks might have a winding quality to them, sort of like those of a fox that is looking for food under bushes and trees. The wolverine is an animal that likes to stay in motion. It is a tireless wanderer that sways its way forward at its own leisurely pace.
Other signs of a wolverine
The wolverine is a skilled climber and its claws might leave marks on pine trunks. In February–March the wolverine will dig a snow cave where it will give birth to its cubs.
In favourable snow conditions the wolverine can kill several reindeer in a short period of time. When it attacks a reindeer the wolverine usually jumps on its back and bites it in the withers and the back of the neck. A prey animal killed by a wolverine will therefore have noticeable contusions and holes in its back and the back of the neck. The wolverine is also a common visitor at the carcasses of animals killed by other large carnivores. If the scene shows signs of a fierce struggle, the animal was probably killed by the wolverine itself.
Droppings
The wolverine marks its territory by biting and urinating on spruce and pine saplings. The look of wolverine droppings varies. They may be dark in colour or they may have bone fragments or hairs in them. They are usually shaped like a sausage that tapers towards the other end. Wolverine droppings are around 2.5 cm thick.
Prey animals
The remains of a hare killed by a wolverine.
An old moose carcass hidden by a wolverine.
Diet and hunting behaviour
The wolverine is a carrion feeder. As a predator it is clumsy when compared to our other large carnivores, but in the winter it can still kill several reindeer in quick succession.
Behaviour and reproduction of the wolverine
The wolverine preys on an extremely wide selection of animals from small mammals to deer species and full-grown reindeer.


Andrew Hardin, a grad student at the University of Colorado, designed these neat, colorful maps that show how long it will take you to move around Boulder, Denver, San Francisco, or Seattle using public transit. Just click any point on the map, and colors pool out around it — like a heat map, but for time spent on buses or subways.
These maps aren't meant to tell you exactly how minutes it'll take a person to get from her front door to a favorite restaurant. FastCoExist:
Hardin's maps, which are based on Open Street Map data, aren't completely accurate. For example, they assume people cross rivers directly, when normally people take bridges or tunnels. "Frankly, better tool exists for planning your commute," he admits. The point is to offer approximations, so you know immediately how far two destinations are from each other.
But they show something more interesting than commute times — the shape of city, as determined by its public transit. You can see, for instance, the impact of train stops, which create distinct circles of time around them, like drops of food coloring on a liquid surface.
Grist thanks its sponsors. Become one.


text:
GEAPS/K-State Grain Elevator Managers Course
May 7-10, 2019
(course minimum – 12 participants)
The GEAPS/K-State Grain Elevator Managers course benefits individuals who are responsible for supervising grain managers. The course focuses on the science behind the practices used in grain management. It provides new managers the information they need to correctly interpret the experiences they will have when managing grain quality, and the insight they will require when evaluating the practices used by their predecessors.
Course Topics: Personnel management; grain quality management; grain handling equipment; grain drying; grain operations costs; grain inventory management; grain receiving and shipping; grain condition monitoring; grain aeration strategies; and fumigation.
Who Should Attend: Industry professionals who work in operations, procurement, management or other grain holding roles.
Registration Fee: $670.00 for GEAPS members and $1,000 for non-GEAPS members person. This fee includes textbook and all instructional material, three lunches, and certificate of completion. Housing and other meals are not included.
Arrival and Departure: Participants must be class at 8:00 a.m. Tuesday of the week they are training and will be finished by 1:00 p.m. Friday.
For more information:

source: m-a-p/FineFineWeb


text:
What is Cubix?
Cubix is a framework for language-parametric program transformation, i.e.: defining a single source-to-source program transformation tool that can be run on multiple languages. In Cubix, you can write transformations with a type signature like "This transformation works for any language that has assignments, loops, and a name-binding analysis," and instantly get separate tools for C, Java, etc. The goal is to radically reduce the cost of building sophisticated whole-program refactoring tools by allowing each tool to be built for a much larger market.
Cubix is based on the idea of incremental parametric syntax, a technique for defining families of representations of programming languages which share common components, and for defining them as a small modification to a pre-existing syntax definition. The name "Cubix" comes from the 2000s television show "Cubix: Robots for Everyone;" in that show, "Cubix" is a robot composed of modular pieces that can be reassembled for many purposes.
The Cubix system itself, and the general incremental parametric syntax approach, is described in the OOPSLA 2018 paper:
- One Tool, Many Languages: Language-Parametric Transformation with Incremental Parametric Syntax*; James Koppel et al
We also recommend reading the following papers to get the necessary background in generic programming to understand Cubix:
- Data Types à la Carte, Wouter Swierstra
- Compositional Data Types, Patrick Bahr and Thomas Hvitved
Transformations in Cubix use our
compstrat library of strategy
combinators. To understand strategy combinators, we recommend the
- The Essence of Strategic Programming, Ralf Lämmel et al
What Cubix is not
Cubix is the world's first framework that can build language-parametric source-to-source transformations. As the first of its kind, it often gets mistaken for a solution to more familiar problems. In particular, it is not:
- A tool for translating one language into another. Cubix allows you to create a single tool that can transform C programs into better C programs and Java programs into better Java programs. It is not designed for building tools that can transform C programs into Java programs. Indeed, much of its power comes from its ability to preserve all the information of the original program.
- A collection of ready-to-use refactoring tools. Thus far, all transformations built on Cubix are tech demos. While a couple are theoretically useful, they have not undergone the amount of UX engineering needed to actually be time-savers.
- A framework for writing multi-language program analyses. Cubix transformations may consume results provided by other analyses, which may be written in either a single-language or multi-language fashion.
- A framework for analysis/transformation of polyglot programs, i.e.: programs (or single source files) written in multiple languages.
However, Cubix's generic-programming capabilities make it a powerful tool for building all kinds of programming tools, even for only one language. We are particularly excited about the potential of extending Cubix to transform polyglot programs.
To build Cubix:
First, download the sub-libraries
git submodule update
Second, build Cubix:
stack build --ghc-options='-O0 -j +RTS -A256m -n2m -RTS'
You may be prompted for your Github credentials to download the third-party frontends.
You are now ready to run Cubix transformations:
stack exec examples-multi java hoist input-files/java/Foo.java
Cubix has many dependencies, several of which are not on Hackage/Stackage, including some forks of Hackage libraries whose changes have not been merged upstream. This makes it more difficult to create a new package which depends on Cubix. For an example of how to do this, see _URL_
Because of performance problems in GHC, the full Cubix will not build with -O1 or -O2. We've tried on a server with 64GB RAM; the server ran out of memory. Instead, use this command:
alias stackfastbuild="stack build --ghc-options='-O0 -j +RTS -A256m -n2m -RTS'"
This builds Cubix in parallel with minimal optimization, and sets the initial GHC heap to larger than usual.
We found the following two minimal sets of compilation flags that mitigate this blowup and make compilation manageable:
1: -fno-cse -fno-full-laziness 2: -fno-specialize -funfolding-creation-threshold=0
If disable everything except CSE and specialise, blow-up still occurs. Remains true with -O1
Adding "--flag cubix:only-one-language" to the build command will turn on a compile flag that disables building support for all languages except Lua, the smallest language. This greatly speeds compilation times, to the point where we are able to compile with -O2. Some of the performance reports in cubix/benchmarks/reports were compiled with this flag.
A Docker image containing the version of Cubix submitted to OOPSLA 2018 along with runs of all the experiments, including the human study, is available from _URL_
Overview of directories (corresponding to the top-level of the zip file, and the /cubix directory on the Docker image):
/stack.yaml # High-level build description /package.yaml # Low-level build description /examples # Example transformations built with Cubix /examples/multi # The main driver for the multi-language transformations /comptrans # Source code for the comptrans library /compstrat # Source code for compstrat, our library for Strategic Programming with Compositional Datatypes /input-files # Small test inputs in each of the 5 languages /scripts # Scripts for running the transformations over compiler test suites
Running the built-in transformations and analyses
Use this command from the "languages" directory (the one that contains "stack.yaml"):
stack exec examples-multi
You will be give the following help:
Usage: examples-multi * examples-multi * Transforms available: debug,id,cfg,elementary-hoist,hoist,tac,testcov,ipt Analyses available: anal-triv-call
Note that only the IPT transformation can be run on multiple files.
It can be faster to run the executable directory, without using
stack exec. On the first author's laptop, this executable is located at
Using the Interprocedural Plumbing Transformation (IPT) Tool
We recommend also using the
rlwrap command to enable command history.
rlwrap stack exec examples-multi java ipt input-files/java/ipt/*.java
In C and Java, you will additionally be prompted for the type of the
parameter to add. Give this type as an AST for
(PrimType IntT), not
Running the language test suites
Cubix comes with scripts for running any semantics-preserving
and Python, in the files
scripts/test_java.rb and similar. To do so:
- Follow the below instructions to install the language tests.
- Each.rb file contains a constant at the top like
JAVA_TESTSpointing to the language implementation and tests directory. Modify these appropriately.
./scripts/test_.rb
These scripts will run the transformation on all tests, run the transformed tests, and report the final pass/fail counts.
For all transformations except
id, they will first run the identity
transformation, and discard any tests that fail. This rules out tests
that trigger bugs in the 3rd party parsers/pretty-printers, most (but
not all) self-referential tests, and tests that the original language
They also come with a special
count_loc parameter that counts the
total lines of code in all relevant tests.
Installing GCC and GCC torture
Note: The C instructions are still being updated.
In some directory:
git clone _URL_ cd gcc # If you want the same revision of gcc-torture as in the paper git reset --hard f72de674726c5d054b9d99b0a4db09dfb52bf494 cd.. mkdir gcc_build cd gcc_build../gcc-mirror/configure make -j8 make install
Installing the K-Java test suite
In some directory:
git clone _URL_ # If you want the same revision as in the paper cd java-semantics git reset --hard c202266304340a2a4be81fa21ee4fe36b3117ee3
In some directory:
The Lua tests
As described in the paper, we had to make several modifications to the Lua test suite to get them to run with Cubix. In particular, we removed several overly self-referential tests, and modified the test suite to report the number of passing/total assertions, rather than aborting the entire suite on the first failure.
These tests are in the
Installing the CPython tests
In some directory:
git clone _URL_ cd cpython git reset --hard 7bd4afec86849a57b48f375a9c4e0c32f0539dad # Only if you want the same revision as in the paper./configure make

source: openbmb/Ultra-FineWeb


Authorization with the Restricted Data Token
How to authorize using the Restricted Data Token.
Operations that return restricted data (such as Personally Identifiable information, or PII) are considered restricted operations, and require special authorization in the form of a Restricted Data Token (RDT). An RDT provides authorization to get the PII required to perform functions such as shipping, tax invoicing, or tax remittance services. You authorize calls to restricted operations by passing an RDT in the x-amz-access-token header when calling a restricted operation. This is in contrast to passing the LWA access token in the header, as you do with other SP-API operations. For more information, see Step 3. Add headers to the URI.
How do I get an RDT?
Unless you have a delegatee application (see Terminology in the Tokens Use Case Guide), you get an RDT by calling the createRestrictedDataToken operation of the Tokens API. If you have a delegatee application, you get an RDT from the delegator application that your application is integrated with. For more information about authorizing calls using the RDT, including delegating authorization, see the Tokens API Use Case Guide.


Figure 1.
Bar graphs of morphological and life-history trait means Daphnia populations in fishless and fish lakes. Fishless populations are shown in black and populations co-occuring with fish in white. A) body sizes; B) clutch sizes; C) offspring sizes; D) instar-specific ages. Bars represent the mean with error bars = 2SE. Significance levels for differences in trait means generated by a NANOVA (* = p < 0.05; ** = p,0.01; *** = p < 0.001). See text for further explanation of trait designations and analysis.
Fisk et al. BMC Evolutionary Biology 2007 7:22 doi:10.1186/_PHONE_-7-22
Download authors' original image


text: Autonomous tugs may play an important role in future ports, due to the shortage of qualified mariners. A digital twin (mathematical model incorporating a vessel's hydrodynamic behavior and response, suitable for real-time control) would be needed for autonomous operations. Yet, partly because tugs are generally high-powered and very maneuverable compared to conventional vessels, there is little published data on the hydrodynamic performance of such vessels. As a first step in the development of the tug's digital twin, the present work studies the maneuvering and seakeeping performance of a generic tug at model scale. Numerical simulations are performed for an approximately 1:10 scale model for standard resistance, static and dynamic captive and seakeeping cases. Reynolds-Averaged Navier-Stokes (RANS) k-ω model is employed for the simulations including the free surface through the Volume of Fluid approach. The hydrodynamic forces and moments on the tug model in the simulations of the standard resistance and the static and dynamic captive cases, as well as the tug model's motions and the added resistance in headseas, are investigated. The simulation results provide data to build a mathematical maneuvering model for the tug based on 4-DoF MMG manoeuvring model, which serves as the digital twin in this case.


text:
Title: A Journey In Southern Siberia The Mongols Their Religion And Their Myths Author: Benjamin Engel Subject: a journey in southern siberia the mongols their.It is a journey that lasts for around. connecting Siberia was proposed by many.A-Z Guide of Trans-Siberian Railway Journey. begin your journey in southern Portugal from.A Journey in Southern Siberia: The Mongols, Their Religion and Their Myths (Paperback).If you are looking for The Origins Of Southern Sharecropping.
Emergence of People in North America. Beringia was a large landmass spreading east from Siberia and extending deep into Alaska. Prehistory of Southern Idaho.Beginning in her hometown of Moscow, Yulya leads us to southern Siberia and ends in Leningrad (now St.
Once-in-a-lifetime Journey along the Trans-Siberian Railway. Scattered across Siberia are countless other beautiful and.Since the Trans-Siberian Railway travels through southern Siberia,.
Famous people of Irkutsk. In 1751 his diaries were published in Gottingen under the title Journey Across Siberia, which was. including Southern Siberia.Join Berg Adventures for a magnificent journey of discovery to Siberia and the. both of the more populated southern end of.The same markers cluster in people who today inhabit the Altay region of southern Siberia, suggesting it was the starting point for.If you are looking for A Journey In Southern Siberia, our library is free for you.


text: The remarkable capability of planarian regeneration is mediated by a group of adult stem cells referred to as neoblasts. Although these cells possess many unique cytological characteristics (e.g. they are X-ray sensitive and contain chromatoid bodies), it has been difficult to isolate them after cell dissociation. This is one of the major reasons why planarian regenerative mechanisms have remained elusive for a long time. Here, we describe a new method to isolate the planarian adult stem cells as X-ray-sensitive cell populations by fluorescence-activated cell sorting (FACS). Dissociated cells from whole planarians were labeled with fluorescent dyes prior to fractionation by FACS. We compared the FACS profiles from X-ray-irradiated and non-irradiated planarians, and thereby found two cell fractions which contained X-ray-sensitive cells. These fractions, designated X1 and X2, were subjected to electron microscopic morphological analysis. We concluded that X-ray-sensitive cells in both fractions possessed typical stem cell morphology: an ovoid shape with a large nucleus and scant cytoplasm, and chromatoid bodies in the cytoplasm. This method of isolating X-ray-sensitive cells using FACS may provide a key tool for advancing our understanding of the stem cell system in planarians.


text:
The Tropf-Blumat Maxi is particularly suitable for large potted plants and tubs up to 30 cm high. The longer design means that moisture can be measured deeper in the soil which leads to ideal conditions in the roots area.
AREAS OF USE:
- Large potted plants
- Ornamental trees
- Individual plants in large pots
- Tubs with container height of over 30 cm
The Tropf-Blumat Maxi works in exactly the same way as a normal Tropf-Blumat. Please refer to the normal Tropf-Blumat instructions for the water supply and general directions for use.
Water the soil well half an hour before insertion! Place the Tropf-Blumat Maxi in the soil down to a depth of approx. 15-18 cm towards the edge of the root cluster, not too close to the stem. Or about 5-8 cm from the edge of the pot in the case of pot plants.
In the case of freshly repotted plants, insert the Maxi directly into the soil (not in the root balls), turning it clockwise, and then press the soil down lightly.
In the case of dense root growth or very hard soil, first pierce a hole towards the edge of the root cluster. Fill the hole halfway up with loose earth then insert the Tropf-Blumat Maxi and water again generously so that the clay tip has good contact with the soil. Then fill the hole up with soil.
The drip tube must protrude 8-10 cm out of the Tropf-Blumat Maxi. Undo the adjustment screw until water runs out of the drip tube. Then turn the screw slowly clockwise until there is just one drop of water left hanging on the drip tube. Then turn the screw tighter by one more marking arrow (1/8 turn).
When using the Tropf-Blumat Maxi for watering, the surface of the soil will be generally dry. This is normal because the Tropf-Blumat Maxi regulates the moisture around the roots.
Regulating the moisture
The length of the drip tube can be reduced to 6 or 7 cm for plants that prefer dry conditions, this shortens the watering time. For moisture-loving plants, the length can be increased to 15 cm. This will lengthen the watering time.


text:
A Answers (1)
NorthShore University HealthSystem answeredThe BRAC Analysis Rearrangement Test (BART) is an additional level of analysis, which goes beyond DNA sequences of genes. BART looks for large rearrangements, deletions, and insertions of DNA material. A positive BART result has the same medical implications as a mutation found with more routine types of analysis. Anyone who has had comprehensive BRCA1/2 testing could go on for BART analysis. It is a matter of yield (chances of finding a mutation), and cost. For high-risk families (multiple cases of breast cancer; early-onset usually; often ovarian cancer in the family), the yield is 1-3%. The cost is $650.


text:
Editor's Note: The following is the final installment in a
series of two articles. Part
1 can be found in Volume 3, Issue 1.
automaton, entitled Kermit the Dog.
a previous article, I discussed the fascinating woodcraft
of automata. In this article, I give a step-by-step explanation
of how to build an automaton and include a detailed plan
that outlines how to make the character described below.
This piece, which on my daughter's suggestion I have called
Kermit the Dog because my character reminded her
greatly of a frog, is adapted from artist Jan Zalud's
Dog That Barks. There are many versions of barking-dog
automata, but I like Jan's the most because of its simple
but clever mechanical design and lifelike result.
Meet the Character
Crank the handle and Kermit charges forward and then retreats
while his mouth opens and closes to mimic a barking motion.
A lever mechanism is used to open and close its mouth.
I used contrasting woods (pine and walnut) for the dog
and the base, and shaped the maple crank handle to resemble

source: HuggingFaceFW/fineweb-edu


Scientists at Oak Ridge National Laboratory has recently developed a graphite foam that useful in doubling the LED lights' lifespan. Graphite foam itself is a lightweight and flexible graphite crystal structure material to work with, creating the possibility of cheaper design with more effective passive cooling elements for LEDs.
This is perhaps also a remark for new wave of game changing technology, where electric car owners will start using electricity to recharge their vehicles, and a reduce in household's lightbulbs electricity usage will in short term, contribute to balance the overall energy consumption level. And hopefully in the long run, more household green energy harvester will be invented, thus further decrease or eliminate electricity bills whenever it is possible.
Base on research conducted by Oak Ridge,'s scientists, a 10-degree decrease in the temperature on an LED is capable to double its lifespan. This is the particular reason behind why LEDs are designed with heat sink components that usually made of copper or aluminum.
[Â Source: CleanTechnica ; Oak Ridge National Laboratory ]


text:
Sudan floods: Parts of White Nile dam collapse
A dam in Tindelti in White Nile state partially collapsed as a result of the floods yesterday.
El Aawar dam sustained damage as a result of the flood of Khor Abuhabil which threatened to drown parts of Tindelti. El Aawar was built to protect Tindelti from flooding in 2013.
The flood of Khor Abu Habil, a seasonal water channel, has accelerated the flow of water and the rise in the water level more than previous years.
Yesterday the state's Ministry of Urban Planning instructed to speed-up the repair of cracks and the development of necessary precautionary measures, in an attempto to not expose the dam to the risk of fully collapsing and drowning Tendelti town.
The overflowing of the Blue Nile in Sennar state caused the pipes that dispose of rainwater on the Singa bridge, to leak. This caused the flooding of El Shargi and Ashara districts in Singa in the past days.
Also the water level of El Dindir river in Sennar continued to rise. The level si recorded at 12.98 metres, marking a significant increase compared to previous rainy seasons.
Back to overview


text:
- Entry at year 1 to Year 6 by taster day or days.
- Formal/informal assessment depending on age.
- Applications welcome from children showing particular abilities in the performing arts, e.g. dance, drama and music.
- £2500 Per term. Fees include lunch, Early Birds from 8am, after school clubs and aftercare to 5pm.
- Broad and balanced curriculum across Early Years, KS1 and KS2
- The emphasis is on the core subjects.
- Specialist teaching of science, music, drama and dance.
- Wide range of peripatetic tuition available.
- LAMDA examination training available.
- Small classes.
The next stage
- Children are prepared for entry to The Hammond School (Lower School), other independent schools, 11+ entrance to Wirral grammar schools, or local state schools.


Create a new collection
A collection is like a folder that contains a group of pages. A page is like a file in your Github repository.
A collection can only exist when there is a page inside. So you must create a page in a collection.
On Github, a collection is a folder
Step 1 Create a file, which will represent a page on your site.
Step 2 Specify the folder name
A folder for a collection should always start with underscore (_). Replace spaces between words with dashes (-).
Always keep all file and folder names in small caps
Step 3 Add a forward slash to fix the folder name and set a file name.
A file name usually corresponds to your page name for easy reference.
By typing the forward slash, you're fixing the file path of the folder
Step 4 Specify the title and permalink of the page
Things to note:
 1. You should enclose the title and permalink inside three dashes ---
 2. Permalink should not have any spaces in between.
 3. If you're creating a page inside a collection, you should specify in the permalink that the page is inside the folder. For example, for a page named My page inside a folder called My New Folder, the permalink will look like this /my-new-folder/my-page/
---
title: New Page
permalink: /my-new-folder/my-page/
---
Step 5 Scroll to the bottom and click commit at the bottom of the page to save the file.


Conversation analytics
Analyze a conversation to better understand the interactions and gain insights about participant behavior.
For example: John and Arya talked over the phone for 60 minutes. John talked for 40 mins. Arya talked for 10 minutes. No one spoke for 10 minutes because John kept Arya on hold.
Use the Get analytics request to view speaker ratio, talk time per speaker, duration of silence, pace, and overlap.
 - Speaker Ratio is the total ratio of a speaker's time spent talking compared to other speakers in the conversation. In our example, the ratio will be 4:1 signifying that John spoke 4 times more than Arya.
 - Talk Time is per speaker. In our example, Talk Time is 40 minutes for John and 10 minutes for Arya.
 - Silence indicates the time during which none of the speakers said anything. In our current example, Silence is 10 minutes.
 - Pace is the rate of speech in words per minute (wpm), per speaker. If John speaks at 100 words per minute, the pace as wpm: 100.
 - Overlap occurs in a conversation if two or more people are speaking at the same time. Analytics reports overlap as a percentage of the total conversation in seconds.
Authentication
This request requires an access token, as described in Authenticate.
Get conversation analytics
This section describes how to get conversation analytics from a conversation. This request requires a conversation ID. You receive a conversation ID when you process a conversation with the Symbl.ai APIs.
To get conversation analytics, use the GET <_URL_ operation:
👍
Try our interactive examples!
We provide interactive versions of these code samples: curl, Node.js, Python
To get started with our code samples, see Set Up Your Test Environment.
ACCESS_TOKEN="<ACCESS_TOKEN>"
CONVERSATION_ID="<CONVERSATION_ID>"
curl --request GET \
 --url "_URL_ \
 --header "Authorization: Bearer $ACCESS_TOKEN" \
 --header "Content-Type: application/json"
import fetch from 'node-fetch';
const accessToken = '<ACCESS_TOKEN>';
const conversationId = '<CONVERSATION_ID>';
const fetchResponse = await fetch('_URL_ {
 method: 'get',
 headers: {
 'Authorization': 'Bearer ${accessToken}',
 'Content-Type': 'application/json'
 }
});
const responseBody = await fetchResponse.json();
console.log(JSON.stringify(responseBody, null, 2));
import json
import requests
access_token = "<ACCESS_TOKEN>"
conversation_id = "<CONVERSATION_ID>"
headers = {
 "Authorization": "Bearer " + access_token,
 "Content-Type": "application/json"
}
response = requests.request(
 method="GET",
 url="_URL_ + conversation_id + "/analytics",
 headers=headers
)
print(json.dumps(response.json(), indent=2))
Where:
For additional reference information, see Get analytics.
Example response
{
 "metrics": [
 {
 "type": "total_silence",
 "percent": 26.245,
 "seconds": 8.22
 },
 {
 "type": "total_talk_time",
 "percent": 73.755,
 "seconds": 23.1
 },
 {
 "type": "total_overlap",
 "percent": 0,
 "seconds": 0
 }
 ],
 "members": [
 {
 "name": "unknown_speaker",
 "pace": {
 "wpm": 246
 },
 "talkTime": {
 "percentage": 100,
 "seconds": 23.1
 },
 "listenTime": {
 "percentage": 0,
 "seconds": 0
 },
 "overlap": {}
 }
 ]
}


text:
Bay Area Discovery Museum
The Bay Area Discovery Museum is designed to ignite creative thinking in children. 7.5 acres of natural beauty inspires families to engage in a world of possibilities. Framed by the majestic backdrop of the Golden Gate Bridge, the Museum is a space for imaginations to run wild. Every curated detail of our exhibits brings creative thinking to life for all stages of childhood. Navigate winding tunnels to develop physical and intellectual risk-taking skills. Feel the rush of cold-water tide pools that surprise and awaken curiosity. Imagine new worlds by transforming into a spider, a ship captain, or a bridge builder. At every turn is a new opportunity to challenge the boundaries of creativity.


Site Feedback
Resolved questions
How to say appraiser and appraisal in Spanish?
I work as an appraiser in areas with a lot of Spanish speakers. I have looked up appraiser in a dictionary and it shows "el tasador". Is this commonly understood? I have never heard it in the field. For appraisal I usually use "valuación". Thanks for your help.
For learning: Spanish
Base language: English
Category: Other
 Please enter between 2 and 2000 characters.
 Sort by:
 Best Answer - Chosen by the Asker
 Appraiser = is the person who calculated a value the price or the rate, to a house or something.
 Appraiser = evaluador, valuador o tasador
 Appraisal = valorización, estimación, apreciación, tasación, evaluación
 In Spain I would say "tasador" and "tasación".
 We had a so big housing bubble, that everyone can understand these two words.
 Submit your answer
 Please enter between 2 and 2000 characters.


text:
This paper introduces a new seven-mass biomechanical model for the vibration of vocal folds. The model is based on the body-cover layer concept of the vocal fold biomechanics, and segments the cover layer into three masses. This segmentation facilitates the model comparison with the motion of the vocal glottis contour derived from modern high-speed digital imaging systems. The model simulation is compared to experimental data from a pair of healthy vocal folds showing good agreement in the frequency and time domains. The proposed model is also shown to outperform a previously-developed model that does not explicitly account for the body layer dynamics.
Volume Subject Area:Biosystems and Biomedical Applications
This content is only available via PDF.
Copyright © 2011


text:
"Nothing's as ugly as overfishing"
WWF's Fish Forward campaign raises awareness of sustainable fish consumption
The provoking and high-impact ad campaign draws consumer's attention towards social, ecological and economic impacts of seafood choices. It highlights global interdependencies of seafood production and consumption and calls attention to the effects of overfished oceans on people in developing countries. The ads underline the fact that choosing sustainable seafood makes a veritable difference. Buying recommendations emphasize the importance of consumer's choices.
The ad campaign was developed by J. Walter Thompson in Vienna and Düsseldorf. International TV spots, print and online ads as well as posters grab consumer's attention – and "make a difference. Choose sustainable fish."


text:
How can I delete a task?
You can delete a task from the List View of Tasks or the Summary View of the record provided you are an Admin user or have delete permissions.
- To delete a task from the List View, go to Essentials > Tasks. Select the task and click the Delete icon displayed above the list view records.
- To delete a task from its Summary View, open the task, click the More icon located beside the task name and click the Delete icon.
© Copyright 2021 Vtiger. All rights reserved.


text:
Rain Garden Cost Share
The purpose of the City of Owatonna Rain Garden Cost Share Program (RGCS) is to promote, facilitate, and increase the number of residential rain gardens in Owatonna by awarding cost share grants for a limited number of residential rain gardens. These rain gardens will be used as educational resources to further promote ways to improve water quality and reduce the risk of localized flooding. Modeled after cost share programs in Rochester and Dakota County, the RGCS program will provide cost share grants of 50% up to $500 to residents who meet eligibility requirements.
View more Rain Garden Design Information.
Homeowners will request a site visit from the Water Quality Specialist.
If all standards are met, homeowner will submit a rain garden budget and design for review.
Application will be reviewed and graded on the criteria included in the documents.
- Application Form (PDF)
- Rain Garden Cost Share Brochure (PDF)
- Rain Garden Design Guidelines (PDF)
- Rain Garden Design Package (PDF)
Properly designed, constructed, and maintained rain gardens have many benefits. They capture rainwater runoff from lawns, roofs, and driveways. Keeping rainwater close to where it falls helps improve and protect the quality of lakes, rivers, and groundwater and reduces the load on the storm sewer system. Rain gardens provide many additional benefits such as adding beauty and value to each home and providing wildlife habitat to attract beneficial birds, butterflies, and dragonflies.
The City of Owatonna will:
- Assist in project guidance of rain garden installation
- Conduct a preliminary site visit to evaluate the feasibility of a rain garden
- Provide cost share reimbursement of 50% up to $500 for approved projects
- Provide landscape design and technical assistance throughout the process
Cost Recipients Agreement
Cost share recipients agree to:
- Allow City staff to take photos and information gained from project for future public education opportunities
- Authorize access by City staff to inspect the project, construction activities, and post-construction conditions
- Maintain the rain garden, ensuring it is functioning as designed
Eligibility & Criteria
The following criteria are minimum eligibility standards and must be met for the applicant to be considered:
- The budget and rain garden plan are reasonable and the rain garden will be installed the growing season immediately following the award notice
- The homeowner enters into an Agreement with the City to maintain the project, ensuring it is functioning as designed
- The rain garden is not required as a condition of development or to satisfy other regulatory requirements;
- The rain garden is proposed on a residential parcel owned by an Owatonna citizen and located within Owatonna City Limits
- The rain garden will be used as a demonstration and education site and will be easily accessible for viewing by the public
- The rain garden will quantifiably reduce storm water runoff, thereby improving water quality
After all program requirements have been met and approved, including a site visit to verify project completion and success, a request for reimbursement may be made. The reimbursement request must include receipts for materials and services purchased. All reimbursement requests for projects completed within a fiscal year must be submitted by December 31st of that year.
The RGCS will increase awareness of stormwater issues and solutions in Owatonna while also providing quantifiable stormwater pollution reductions that Owatonna can use towards future TMDL restrictions. This program will help satisfy Owatonna's MS4 Minimum Control Measures:
- Pollution Prevention and Good Housekeeping
- Public Education and Outreach
- Public Participation and Involvement


phere 5.1
See also Methods To Provide Vm Data Backup
VM
Does Veeam require vCenter?
There is a lot of confusion around whether or not Veeam Backup & Replication (VBR) requires vCenter. The answer is a little bit complicated.
First of all, VBR requires vSphere to run. vSphere is VMware's flagship product that allows users to create and manage virtual machines. vCenter is a component of vSphere that provides enhanced functionality, such as the ability to centrally manage multiple vSphere hosts.
That said, VBR does not require vCenter to function. You can use VBR without vCenter to back up and replicate virtual machines, provided you have access to vSphere. However, using VBR without vCenter will be less efficient and you will have limited functionality. For example, you will not be able to use VBR's automation features without vCenter.
So, to answer the question, Veeam Backup & Replication does not require vCenter, but it is highly recommended that you use it in order to get the most out of the product.
How do I add a standalone host in Veeam?
Adding a standalone host in Veeam is a straightforward process that can be completed in a few minutes. In this article, we will show you how to add a standalone host in Veeam and configure it for backup.
To add a standalone host in Veeam, you need to log in to the Veeam Backup & Replication console and select the Hosts tab. Then, click the Add button and select the standalone host you want to add.
Next, enter the IP address or the DNS name of the standalone host and click the Add button. The standalone host will be added to the list of hosts and will be ready for backup.
In order to configure the standalone host for backup, you need to specify the type of backup you want to perform. You can choose between full backup, incremental backup, and differential backup.
You can also choose the backup schedule and specify the backup repository. The standalone host will be added to the backup schedule and will start backing up immediately.
That's it! You have successfully added a standalone host in Veeam and configured it for backup.
How do I use VMware to backup Veeam?
VMware and Veeam are both powerful tools used in data centers and businesses around the world. VMware is used to create and manage virtual machines, while Veeam is used to backup and protect data.
In order to use VMware to backup Veeam, you will need to install VMware on your computer and create a virtual machine. Once the virtual machine is created, you will need to install Veeam on the virtual machine. Once Veeam is installed, you can create a backup job and schedule it to run automatically.
VMware is a powerful tool that can be used to backup Veeam. By using VMware, you can create a virtual machine and install Veeam on the virtual machine. This will allow you to backup your data and protect it from loss or damage.


kill (v.) Look up kill at
c. 1200, "to strike, hit, beat, knock;" c. 1300, "to deprive of life," perhaps from an unrecorded variant of Old English cwellan "to kill" (see quell), but the earliest sense suggests otherwise. Sense in to kill time is from 1728. Related: Killed; killing. Kill-devil, colloquial for "rum," especially if new or of bad quality, is from 1630s.
kill (n.2) Look up kill at
"stream," 1630s, American English, from Dutch kil, from Middle Dutch kille "riverbed," especially in place names (such as Schuylkill). A common Germanic word, the Old Norse form, kill, meant "bay, gulf" and gave its name to Kiel Fjord on the German Baltic coast and thence to Kiel, the port city founded there in 1240.
kill (n.1) Look up kill at
early 13c., "a stroke, a blow," from kill (v.). Meaning "act of killing" is from 1814; that of "a killed animal" is from 1878. Lawn tennis serve sense is from 1903. The kill "the knockout" is boxing jargon, 1950.


Type Checking Modular Multiple Dispatch with Parametric Polymorphism and Multiple Inheritance
The Formalization in COQ might also be of interest to some.
Comment viewing options
Most specific instance selection
Thanks for the post, Sandro. This fits in well with our recent discussions on overloading.
I wonder if someone can justify this mechanism on semantic grounds. Why is it a good idea to even be asking the question of which is the most specific instance? When we are defining a function by pattern matching, we don't list a bunch of patterns in random order and let the compiler tease out which pattern is most specific. It seems to me that there are two cases with overloads:
1. At least one of the overloads is aware of the other and there is a particular order in which overloads should be tried (using the first that applies). This is the case with typical pattern matching of closed algebraic datatypes.
2. The overloads are mutually unaware of each other. In this case, I would argue that no ambiguity should be tolerated. Even if one is more "specific" than another, that may be accidental and shouldn't be used to resolve the overload.
It seems likely to me that the idea of "most specific dispatch" arose out of an attempt to handle both of these cases with a single mechanism. I'd question whether that is a good idea.
Your second case is handled
Your second case is handled in Fortress using the meet rule, where the definitions of each overloaded function must form a meet semilattice, ie. in the paper's words, "The Meet Rule requires every pair of declarations to have a disambiguating declaration, which is more specific than both and applicable whenever both are applicable. (If one of the pair is more specific than the other, then it is the disambiguating declaration.)".
If I understand you correctly, you're positing a scenario where some function foo has definitions on types (t1, t2) and (t0, t3) but dispatched on (t1, t3), where t1 <: t0 and t3 <: t2. In this case, the second definition isn't aware of the first, nor the first aware of the second. The meet rule would require a disambiguating overload to resolve this case.
Edit: as to whether it's a good idea, I'm not sure. I think most of the difficulties arise from the pervasive subtyping of Fortress. I can imagine a simpler language with more controlled subtyping, like an algebraic constructor being its own type that's a subtype of the algebraic type, to be much more straightforward.
Not that case, exactly
For example if one module defines f(Nat) and another f(Number), I'm saying it is a mistake to not report the ambiguity just because Nat is more specific. It's possible the person writing the call only had in mind the Number definition.
Perhaps a more specific
Perhaps a more specific example where this would be undesirable might demonstrate why this would be a bad idea. I'm not seeing how your example differs from overriding a method f by inheriting from Number. The code calling f on Number would know that it's calling a method that could be overridden by any subtypes.
I read this as "most OO languages don't have sensible semantics anyway, so how is this any different?" Fair enough, but I think you can often interpret object encodings in a somewhat sensible way, with methods contributing both an interface and a default implementation. A subclass can be seen as overriding the default implementations while building a record of methods. There is no "most specific type" based dispatch going on in this view, even if that would produce the same result. When we switch to multi-methods, there is no longer a corresponding (somewhat) sensible semantics.
When we switch to
Isn't there? What's the meaning of "sensible"? The Fortress semantics seem quite sensible to me, which is why I asked for a specific example where you think it, or even a single inheritance overriding, isn't sensible and so I can understand precisely what that means.
Edit: consider the example I brought up earlier, of limited subtyping where sum constructors are types that subtype the sum type itself. "Most specific" is then simply pattern matching, and moreover enables a form of extensible sums and cases. There doesn't seem to be anything nonsensical about the principle of "most specific" itself, so what I'm trying to say is that I think your problem with Fortress or multimethods probably lies elsewhere, like with the pervasive subtyping.
"Most specific" is then
But one that suffers from the problem of more specific patterns silently overriding more general patterns. In a modular setting, this looks like a misfeature to me. The "more specific than" relation looks like a proxy for "is intended to specialize". That seems dangerous when these patterns are spread among modules and the authors might not even be aware of each other.
Dangerous and Useful
Usually these specialisations are different algorithms that do the same thing. For example sorting is a family of algorithms. Current languages only impose syntactic and type constraints on the specialised algorithms in a family, but ideally there should be semantic constraints in the form of axioms.
However there will always be things that are difficult to enforce, for example how do you prove that vector addition is actually the same thing as integer or floating point addition.
Rust actually places constraints on where implementations can be declared, which is more restrictive than the axiomatic approach but much simpler to implement. Rusts rules are something like you can only implement a trait declared in another module for a type declared in the same module as the implementation. This leads to the common pattern of declaring a wrapper type in your module to allow you to implement library traits on generic type parameters (which might be instantiated with types declared elsewhere, so you need to wrap in a local type). This means you cannot redefine addition in integers, but you can define a wrapper and redefine addition on wrapped integers. Its overly restrictive because you cannot redefine addition on types that implement the integer-trait, because some of those types might already have addition defined elsewhere, but you can redefine addition on types that implement the integer-trait, and are wrapped in your local type wrapper.
Obviously these features have uses that would be affected if you just removed them and didn't replace them with anything else, but that's usually true for bad features as well as good ones. The question is whether the proposed mechanism is better than alternatives.
I'm generally skeptical of the approach to language design that starts with a mechanism and tries to tweak it until it has nice properties. I'd prefer to start by finding semantics that faithfully model the aspects of the problem we are interested in and then build a language around that semantics. "Most specific" dispatch still seems to me to be a fairly ad hoc mechanism.
Programming as Abstract Algebra
We want to model abstract algebra, so we start with implementing algorithms over common algebraic concepts (Elements of Programming, chapters 1 - 5). Then we understand the patterns of abstract algebra, we can look at algorithms over core computer science concepts like containers. It turns out the algebraic structure of containers can be modelled by a family of iterators, and so we explore the algorithms that can be implemented in terms of different iterators (Elements of Programming, chapters 6 - 9). Then we take what we have and look at how we can do something useful like rearrangements and rotations (which are very useful generic algorithms that turn out to have all sorts of uses, Elements of Programming, chapters 10 - 11). This includes algorithm selection which is where you want trait (or type-class) based dispatch, and specialisation, as you want to select the optimal rotation algorithm depending on the type of iterator supported by the container. This relies on the earlier decision that containers should only implement iterators that are efficient for that container (which follows the general principles of abstract algebra).
So this is all part of a disciplined mathematical model, and not ad-hoc in any way. Reading Elements of Programming should make this clear. Watching this video is a good place to start: _URL_
a use of lazy eval or something more sophisticated
I like the idea of specifying algorithms in the simplest forword form, and yet being able to pull data through layers of them as needed.
But lazy eval at least as implemented in haskell has the idea that if you can access an old calculation, it has to be persistent for the life of the program - it has no optimization that says it's sometimes better to stop caching and recalculate later.
I once tried to do this sort of thing with layers of ring buffers and optimized loops using templates in c++ (I was doing sound processing).
I never figured out why pulling data through many layers of these was slow - I thought I calculated the size and use of the buffers to not have to recalculate on normal use.
But I like this idea best:
YOu specify the algorithm in its simplist form, maybe with some small hint about needed overlap and expected block size, and another program optimizes the buffers and partial generators behind your back.
In other words I want a new model of computing based on metaprogramming!
Lazy evaluation is a misfeature
The problem with lazy evaluation is that the performance is very unpredictable and difficult for people to understand. Having spent some time writing large programs in Haskell, I now think default lazy evaluation was a misfeature. I prefer Rust's eager approach, as performance is much more predictable and understandable. I don't think you actually need lazyness, as you can just use an object and an iterator. If you always access collections through an iterator interface (which I think is the right way to do


text:
If your computer is running hot or battery is running out quickly, then it is most likely due to some application or process consuming high CPU or memory. If you keep running applications for a long time, for example, Outlook, then it continues to grow in memory consumption and does not free up memory efficiently. As a result, your computer runs out of physical memory and other applications run slower. Sometimes Outlook, browser, image editing applications or some other applications start taking full CPU as they get into some infinite loop and make your CPU hot and you get sluggish performance from your application.
CPUAlert is an application that monitors CPU and memory consumption of applications and alerts you if some application is consistently taking high CPU or high memory. It will not only save your CPU and battery's lifetime but also make your computer run smoothly and let your active applications run as fast as possible.
How to Use the Application
While it is running, if some process is consuming more than 200 MB memory, it will show you an alert:
Here you can see that my Outlook is taking 244 MB of physical RAM.
You can either postpone the alert for 5 mins (just press ESC), or ignore the process permanently so that you no longer receive alerts for the process anymore, or you can close it and reclaim memory.
The handy feature is "Restart" which closes the application and starts again. This generally frees up memory that clogs up the process.
The same alert will come up if some process is consuming more than 30% CPU for over 5 mins.
You can configure all these settings like what's the tolerable limit for CPU and memory, how frequently to show the alert, how long to wait before closing an application, etc. by right clicking on the Task bar icon and choosing Settings.
The application registers itself to start at Windows startup. If you want to remove it from Windows Startup, just delete the application shortcut from Start Menu->All Programs->Startup menu.
Using the Code
CPU Alert is a small project. The important files are:
- MonitorCPUForm.cs: This is the main window which is loaded when the app starts. It hides itself in the system tray and keeps the app running in background. It also hosts a "Settings" view which lets you change the CPU and Memory threshold, alert interval, etc. It also orchestrates the operations and shows the necessary alerts.
- KillProcessForm.cs: It has just the UI for the alert that you see in the above popup. No intelligence.
- Monitor.cs: This is the important class that does the monitoring, measurement of CPU and Memory usage and raises the alert. If you want to have this kind of feature in your application, you can reuse this class.
Let's look at the Monitor.cs class first which has the brainpower to monitor CPU and memory. It uses WMI to monitor the processes. I tried using
Process class first and tried to access the
TotalProcessorTime but it gave me "Access Denied" for processes like
mysqld. For some processes, I did not get the
WorkingSet and so on. Then I tried using
PerformanceCounter to get the CPU and Memory usage of process. It was too expensive to query Performance Counter for each process. So, I had to rely on WMI to give me the information.
private ManagementObjectSearcher _Searcher =
"SELECT IDProcess, Name, PercentProcessorTime, Description,
WorkingSet FROM Win32_PerfFormattedData_PerfProc_Process");
private List GetUsage()
var processes = new List();
foreach (ManagementObject queryObj in _Searcher.Get())
var process = new ProcessInfo
Id = Convert.ToInt32(queryObj["IDProcess"]),
Name = Convert.ToString(queryObj["Name"]),
CpuUsage = Convert.ToInt32(queryObj["PercentProcessorTime"]),
Description = Convert.ToString(queryObj["Description"]),
WorkingSet = Convert.ToInt64(queryObj["WorkingSet"]),
process.Title = process.Name;
process.Title = process.Description;
if (process.Id > 0)
Pretty straight forward. The only cool thing to learn here is I declared the
ManageObjectSearcher as a
private variable, not a local variable to this function because it seems creating and disposing it every time the
GetUsage function is called is very expensive. CPU was getting 20% for about 30 seconds on
WMIpserv.exe whenever I tried to create and dispose the searcher.
Closing a process turned out to be a R&D challenge. You can kill a process by calling
Process.Kill, but that terminates the process abnormally. If you are killing Outlook this way, it causes data corruption. So, you have to gracefully close the application. However, if some app is stuck and taking 100% CPU, trying to close it gracefully does not work. You have to take drastic measures. In that case, killing it is only the solution.
So, first I try to close the process gently:
private void CloseProcess(ProcessInfo processToKill)
Process process = Process.GetProcessById(processToKill.Id);
processToKill.Path = process.MainModule.FileName;
catch (Exception closeException)
if (MessageBox.Show(this, "Unable to close process: "
+ (processToKill.Title) + Environment.NewLine
+ closeException.Message + Environment.NewLine
+ "Do you want to kill it?", "Unable to close process",
MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
Here it calls the
Process.CloseMainWindow function to send a shutdown message to the process. If the process has a visual window, it will receive the message and hopefully it will close itself soon. If there's no visual window, then it will not receive the message and it will not shutdown. So, we will have to kill it.
Even if some process receives the shutdown message, it may not terminate properly if it's stuck in some infinite loop. In that case, we need to check back after a while if it's still running and then kill it.
private void KillProcess(ProcessInfo processToKill)
foreach (Process process in Process.GetProcessesByName(processToKill.Name))
if (process.Id == processToKill.Id)
catch (Exception killException)
MessageBox.Show(this, "Unable to kill process: "
+ Environment.NewLine + "You should restart your computer",
"Unable to kill process",
This function is fired from a timer. We wait for a while and then go for the kill. First check, if the process is still lying around. If it is, then kill it.
Another interesting topic is memory usage. As you know, Windows Forms apps when started, take up about 10 MB to 15 MB memory. It's too much for a utility which is running in the background and trying to save you some memory. It's because when.NET WinForms libraries load, they load a lot of stuff hoping you would need it and it would save additional load time. So, I had to force.NET to flush out any unused stuff. I have a
MemoryHelper which does this:
static class MemoryHelper
static extern int EmptyWorkingSet(IntPtr hwProc);
public static void ClearMemory()
First it forces a Garbage Collection, then it calls the
EmptyWorkingSet function on
psapi.dll to flush out the working set, which is the physical memory allocation. I don't know whether or not it works, but at least Taskbar shows that the app now takes only 5 MB memory. Super!
CPUAlert will save you from slowing down your PC or burning out laptop batteries quickly. If you find it useful, please spread the love. Start by voting for this article.
- 2nd March, 2010: Initial post


text:
Development of a Tri-Axial Cutting Force Sensor for the Milling Process
AbstractThis paper presents a three-component fixed dynamometer based on a strain gauge, which reduces output errors produced by the cutting force imposed on different milling positions of the workpiece. A reformative structure of tri-layer cross beams is proposed, sensitive areas were selected, and corresponding measuring circuits were arranged to decrease the inaccuracy brought about by positional variation. To simulate the situation with a milling cutter moving on the workpiece and validate the function of reducing the output errors when the milling position changes, both static calibration and dynamic milling tests were implemented on different parts of the workpiece. Static experiment results indicate that with standard loads imposed, the maximal deviation between the measured forces and the standard inputs is 4.87%. The results of the dynamic milling test illustrate that with identical machining parameters, the differences in output variation between the developed sensor and standard dynamometer are no larger than 6.61%. Both static and dynamic experimental results demonstrate that the developed dynamometer is suitable for measuring milling force imposed on different positions of the workpiece, which shows potential applicability in machining a monitoring system. View Full-Text
Share & Cite This Article
Li, Y.; Zhao, Y.; Fei, J.; Zhao, Y.; Li, X.; Gao, Y. Development of a Tri-Axial Cutting Force Sensor for the Milling Process. Sensors 2016, 16, 405.
Li Y, Zhao Y, Fei J, Zhao Y, Li X, Gao Y. Development of a Tri-Axial Cutting Force Sensor for the Milling Process. Sensors. 2016; 16(3):_URL_ Style
Li, Yingxue; Zhao, Yulong; Fei, Jiyou; Zhao, You; Li, Xiuyuan; Gao, Yunxiang. 2016. "Development of a Tri-Axial Cutting Force Sensor for the Milling Process." Sensors 16, no. 3: 405.
Note that from the first issue of 2016, MDPI journals use article numbers instead of page numbers. See further details here.


ALL ARTICLES
SHARE
How Flatirons Fuse Delivers Front-end Validation
author-avatar
Development
6 min read
front-end validation
One of the key issues facing CSV importers typically built by in-house development teams is clear validation on the front-end. Customers are often left with vague errors offering little insight into why their CSV or spreadsheet import failed.
Technical error message when importing data
The developers may have clues as to what went wrong based on reviewing logs and troubleshooting techniques, but the customer is frustrated to have to contact support to resolve issues that the user could fix themselves if the problem was clearly communicated initially. This is where validation, (front or back-end) comes in. It offers the user clear indications of where the problem is, and ideally, how to solve it.
But how do we do it?
Initializations and Hooks
Our front-end validations kick into play when you first attempt to submit the data you are attempting to migrate into the target system. Rather than simply telling you that the import failed, it will tell you any known issues that will prevent the import from working. The most basic and commonly used validation is email. If you select Email as a data type in the columns of your template, our system recognizes if the data in that field does not correspond to the standard email configuration (it recognizes if there is no @ symbol or does not end in .com). This is done via initializations and hooks. This example is included and requires no configuration on our customers' part.
Descriptive technical error message when importing data
The below hooks and initializations produce similar validations to the above, tailored to your specified requirements. As you can see, the error is easily seen and dealt with prior to upload.
Let's look at how this type of validation is done. Our system makes use of initializations and hooks. The initialization does exactly what it says – initializing your embedded data importer. It requires the organization ID, and the template ID to initialize.
const importer = new FuseImporter(organizationApiKey, templateId);
const importer = new FuseImporter(organizationApiKey, templateId);
Once initialized, functions and hooks are used to deliver the desired validation. The show function launches the importer, provided it is properly initialized.
importer.show();
importer.show();
Next, we have several basic types of hooks that can be triggered for validations.
OnValidateRecord (record)
This hook is called upon by each record (row) in a customer's CSV or spreadsheet import. In it, you can specify custom front-end validations and display error messages in the importer that the user is then able to identify and fix (This is the hook used to bring attention to email addresses in the example above). When you create a Template, each column contains an internal key. These internal keys represent the following return values:
 1. If there is no error, the expected return should be an empty value (no change necessary)
 2. If there is a validation error within the record, you can specify the error as shown below:
importer.onValidateRecord = async (record) => {
 const errors = {};

 // force emails to include gmail
 if (!record.email?.includes("gmail")) {
 errors['email'] = "Email must from gmail"
 }
 return errors;
};
importer.onValidateRecord = async (record) => {
 const errors = {};

 // force emails to include gmail
 if (!record.email?.includes("gmail")) {
 errors['email'] = "Email must from gmail"
 }
 return errors;
};
As you can guess in the example above, the validation here is looking for only Gmail email addresses. In the 'if' line, we see the condition set that the record must include Gmail. Then in the line below, we see that an error message is specified to be shown to the user: "Email must be from Gmail". By extrapolating, you can see how this would be used to validate general emails as discussed in the introduction – a couple of conditional lines to ensure that the @ symbol is present, as well as .com. The error message specified might be "You have email entries that are incorrectly formatted." This type of validation is great for conditions in which there are multiple possible options to fix the record, but when you cannot risk overwriting an outcome. For example, if as shown in the above example an email address is not a Gmail address, the system would not necessarily be correcting anything by simply overwriting the company name or other suffix used for the email. It is up to the user to determine the best course of action.
FormatRecord(record)
The formatRecord hook is used in situations where you want to save the customer some effort and format data automatically for them. For example, if you have a field called first_name, and you know that your system always requires the first_name to be capitalized, you can call on this hook to format the first letter automatically.
importer.formatRecord = (record) => {
 const newRecord = { ...record };
 // capitalize first letter in first_name
 if (typeof newRecord.first_name === "string") {
 newRecord.first_name = newRecord.first_name.charAt(0).toUpperCase()
+ newRecord.first_name.slice(1);
 }
 return newRecord;
};
importer.formatRecord = (record) => {
 const newRecord = { ...record };
 // capitalize first letter in first_name
 if (typeof newRecord.first_name === "string") {
 newRecord.first_name = newRecord.first_name.charAt(0).toUpperCase()
+ newRecord.first_name.slice(1);
 }
 return newRecord;
};
The above code states that if the type of data in the record is a string entry, and is named first_name, the character at 0 (the first character) will be changed to uppercase. This type of code can be used to capitalize letters automatically or to ensure state abbreviations are capitalized, or in any situation where a simple and always necessary format change can be applied.
Meeting Your Needs
The above hooks can be modified to fit your use case, either formatting necessary records automatically or providing front-end validations before submitting your CSV or spreadsheet to the target system. With only a few lines of code for each data transformation or validation, you can ensure that the transformation and loading portion of the ETL (Extract, Transform, Load) process is seamless for your clients. If you need help in configuring your unique requirements, we at Flatirons Fuse are here to help.
Professional CSV Import Solution
Flatirons Fuse is an enterprise-grade, embeddable CSV import solution.
Learn more
Professional CSV Import Solution
Flatirons Fuse is an enterprise-grade, embeddable CSV import solution.
Learn more
author-avatar
More ideas.
Development
tRPC vs GraphQL: Which API Is Best for You?
Flatirons
May 15, 2024
Development
Choosing the Best Flutter IDE for App Development
Flatirons
May 14, 2024
Development
PWA vs. Native Apps: A Comparison
Flatirons
May 13, 2024
Development
The Key Roles in a Software Development Team
Flatirons
May 11, 2024
Development
How to Write Clean and Maintainable Code
Flatirons
May 10, 2024
Development
How to Hire an Offshore Developer
Flatirons
May 09, 2024
Development
tRPC vs GraphQL: Which API Is Best for You?
Flatirons
May 15, 2024
Development
Choosing the Best Flutter IDE for App Development
Flatirons
May 14, 2024
Development
PWA vs. Native Apps: A Comparison
Flatirons
May 13, 2024
Development
The Key Roles in a Software Development Team
Flatirons
May 11, 2024
Development
How to Write Clean and Maintainable Code
Flatirons
May 10, 2024
Development
How to Hire an Offshore Developer
Flatirons
May 09, 2024


text: A temperature dependence characterization system of microwave permeability of magnetic thin film up to 5 GHz in the temperature range from room temperature up to 423 K is designed and fabricated as a prototype measurement fixture. It is based on the near field microwave microscopy technique (NFMM). The scaling coefficient of the fixture can be determined by (i) calibrating the NFMM with a standard sample whose permeability is known; (ii) by calibrating the NFMM with an established dynamic permeability measurement technique such as shorted microstrip transmission line perturbation method; (iii) adjusting the real part of the complex permeability at low frequency to fit the value of initial permeability. The algorithms for calculating the complex permeability of magnetic thin films are analyzed. A 100 nm thick FeTaN thin film deposited on Si substrate by sputtering method is characterized using the fixture. The room temperature permeability results of the FeTaN film agree well with results obtained from the established short-circuited microstrip perturbation method. Temperature dependence permeability results fit well with the Landau-Lifshitz-Gilbert equation. The temperature dependence of the static magnetic anisotropy HK sta, the dynamic magnetic anisotropy H K dyn, the rotational anisotropy Hrot, together with the effective damping coefficient eff, ferromagnetic resonance f FMR, and frequency linewidth f of the thin film are investigated. These temperature dependent magnetic properties of the magnetic thin film are important to the high frequency applications of magnetic devices at high temperatures. © 2011 American Institute of Physics.


exposure.
Uncured resin with 0% degree of cure has a log(IV) = 6.9 and fully cured resin, presumed to be 100% degree of cure, has a log(IV) ~10.8. For many thermosets and polymers, the change in log(IV) is proportional to the change in degree of cure, therefore by interpolation it is possible to correlate cumulative relative exposure with both an ion viscosity and a degree of cure.
Figure 5. Maximum ion viscosity and degree of cure for U3345 vs. cumulative relative exposure
Figure 5 shows log(IV) and degree of cure increase in proportion to the cumulative exposure, until reaching a maximum value that corresponds to complete cure. This result is expected because the total amount of activated photoinitiator is proportional to the total irradiation, and the amount of activated photoinitiator, in turn, determines the extent of polymerization. If absolute irradiance could be measured at the sample, then it would be possible to relate cumulative exposure with the resulting degree of cure.
Cure inhibition from long exposures
Figure 6. Ion viscosity of U3345, showing cure inhibition
Curing behavior with long exposures may have significantly different dynamics compared to brief exposures. Figure 6 plots ion viscosity for four tests with increasing exposure times.
1) Relative irradiance = 9.3, exposure time = 1 s. Ion viscosity increases normally and monotonically through UV and dark cure to the plateau of log(IV) ~10.8, indicating a typical approach to 100% degree of cure.
2) Relative irradiance = 15.3, exposure time = 5 s. Ion viscosity shows a very slight knee at about 9 s (4 s after start of exposure) then a typical approach to 100% degree of cure.
3) and 4) Relative irradiance = 15.3, exposure time = 10 s and 20 s. Ion viscosity shows a pronounced knee at about 9 s (4 s after start of exposure) while temperature continues to increase significantly due to the intense light. Log(IV) decreases until the end of exposure at 10 s for curve 3, and 20 s for curve 4. Subsequently, dark cure proceeds to the ion viscosity plateau and 100% degree of cure.
This "knee" in ion viscosity has been observed in thermally cured resins (thermosets) if cure stops during an increasing temperature ramp.8 Ion viscosity is determined by both degree of cure and temperature, and has two basic behaviors:
 - At constant temperature, ion viscosity increases as degree of cure increases.
 - At constant degree of cure, ion viscosity decreases (increases) as temperature increases (decreases).
Normally, log(IV) increases as cure advances, and in most cases this response dominates even as temperature increases. However, if cure stops while the temperature continues to increase, then the degree of cure is constant, and ion viscosity decreases, resulting in the "knee."
Similarly, for U3345, the knee in log(IV) – slightly visible for curve 2, prominent in curve 3 and even more prominent in curve 4 – indicates polymerization has stopped. In fact, cure has been temporarily inhibited, because ion viscosity increases again after exposure ends and the U3345 undergoes dark cure.
Since ion viscosity in Figure 6 reaches the maximum value of ~10.8 (100% degree of cure) for each of the four curves, the U3345 has experienced only a delayed time to end of cure for the 5-, 10- and 20-second exposures. This cure inhibition may be a general phenomenon because it has been observed in all of four UVcured resins examined to date.
Figure 7. Determination of cure inhibition time
It is difficult to determine a precise time for the start of cure inhibition, but it can be estimated by the intersection of asymptotes on either side of the knee, as shown in Figure 7. Cure inhibition time is defined as the difference between the start of exposure and the start of cure inhibition. Figure 8 plots the cure inhibition times for several tests across a range of irradiance. The quantity of activated photoinhibitor increases with irradiance, and the trend line of Figure 8 shows increasing irradiation corresponds with shorter inhibition times. This relationship suggests a connection between the level of activated photoinitiator (or, conversely, photoinitiator depletion) and the onset of cure inhibition.
Figure 8. Cure inhibition time as a function of relative irradiance
Cure inhibition cannot be due to the depletion of activated photoinitiators because dark cure indicates the continued presence of initiating radicals. It is possible cure inhibition results from high exposures that generate too many initiating radicals, which encounter and cancel one another. High exposures also may create excessive amounts of short polymer chains and no long ones. Perhaps bleaching of all photoinitiators eliminates screening of UV radiation from the monomers, causing them to absorb UV photons and become too energetic to bond. Although the cause of cure inhibition is not yet known, further study may yield interesting information about photoinitiator chemistry.
Cure degradation from long exposures
Figure 9. Ion viscosity of U3345, exposure time = 30 s
Long exposures with high irradiances risk over-cure and degradation of a UV-cured adhesive. Figure 9 shows the progression over three tests of increasing irradiance with an exposure time of 30 seconds.
1) Relative irradiance = 2.1, exposure time = 30 s. Normal cure but total energy is only sufficient to achieve final log(IV) = 10.2 and degree of cure = 85%.
2) Relative irradiance = 2.9, exposure time = 30 s. Normal cure and total energy sufficient to achieve final log(IV) = 10.7 and degree of cure ~100%.
3) Relative irradiance = 3.4, exposure time = 30 s. Cure shows cure inhibition and over-cure from excessive total energy, resulting in reduced final log(IV) = 10.1 and degradation.
Figure 10. UV damage with increasing exposure
Compared to the value at 100% degree of cure, a reduction in final ion viscosity, despite greater irradiance, indicates the presence of damage. Lower ion viscosity is the result of greater conductivity (lower resistivity) due to degradation byproducts and broken bonds. Figure 10 shows four tests with varying irradiances and exposure times. Lack of absolute UV power measurements necessitates use of relative exposure, given by Equation 2, to allow comparison among tests:
Equation 2. Relative exposure = Relative irradiance • time (s)
Test 1, with a relative exposure = 87, shows normal cure that achieves log(IV) ~10.7 and ~100% degree of cure. Tests 2, 3 and 4 have higher relative exposures but lower final ion viscosities, with log(IV) ~10 – a clear sign of degradation. Additional evidence of degradation are irregular features such as the dip starting at 30 s in Test 2.
Figure 11. Correctly exposed (a), slightly (b) and significantly overexposed (c) samples
Figure 11 shows the effect on UV-cured resin with different degrees of exposure. Extreme deterioration (Figure 11 b and c) is apparent as voids from overheating. More subtle degradation is visible as yellowing or discoloration, which may be faint or subjective. Dielectric measurements, however, can provide a supplemental, objective measure of damage caused by overexposure.
Real-time dielectric cure monitoring (DEA) of UV-cured resins can complement traditional laboratory tests to relate degree of cure and exposure energy, measure the effect of formulation on cure and identify degradation from overexposure. The ability of dielectric cure monitoring to capture events in real time allows observation of transient phenomena such as cure inhibition, which appears to be a response of UV-cured resins in general to very long exposures.
The authors would like to thank Uvitron International for the SunSpot 2 UV Spot System and H.B. Fuller for the UV-curable materials used in this study. In addition, we would like to thank Martin Thompson of Domino Printing for comment and discussion.
 1. U3345™ UV-curable adhesive, manufactured by Cyberbond Europe GmbH, Wunstorf, Germany
 2. Application Note 3.22, "Cure Index and Degree of Cure," Lambient Technologies, Cambridge, Massachusetts, US.
 3. J.H. Chen, M.A. Octeau, M. Hojjati and A. Yousefpour, "Cure Cycle Optimization for Composite Panels Fabricated by RTM Using Dielectric Sensors," National Research Council Canada, Institute for Aerospace Research, ICCM International Conferences on Composite Materials (2009).
 4. Day, D.R., "Dielectric Determination of Cure State During Non-Isothermal Cure," Polymer Engineering and Science; 29(5):334-338, (August 2004).
 5. Quarto-Varicon™ sensor, manufactured by Lambient Technologies, Cambridge, Massachusetts, US.
 6. SunSpot 2™, manufactured by Uvitron International, Inc., West Springfield, Massachusetts, US.
 7. LT-631™ High Speed Dielectric Cure Monitor, manufactured by Lambient Technologies, Cambridge, Massachusetts, US.
 8. Application Note 3.21, "Measuring Degree of Cure with Dielectric Cure Monitoring," Lambient Technologies, Cambridge, Massachusetts, US.


text:
- TRAILS - MODERATE
- SCENIC OVERLOOK
Clark Nature Preserve
Lancaster County Conservancy Nature Preserve and hiking trails
Formerly three separate nature preserves known as House Rock, Reed Run, and Pequea South, Clark Nature Preserve was created and named in 2021 in honor and recognition of an extraordinary gift by the Clark Associates Charitable Foundation, in celebration of the Clark Associates' 50th Anniversary.
This preserve highlights a variety of native species including oaks, blueberries, ferns, and other acidic loving plants on scenic wooded slopes. There are areas that are an experimental American chestnut planting in partnership with the American Chestnut Foundation. Some unique features of this preserve is Wind Cave (also known as Cold Cave for consistent near freezing temperatures year-round), one of the largest tectonic (fault) caves in the eastern United States. The Clark nature Preserve features a combination of forest and field habitats that attract white-tailed deer and wild turkeys Three beautiful river hills streams, House Rock Run, tiny Brubaker Run, and the larger Reed Run, flow through the woods of the preserve with many small waterfalls as the streams descend to the Susquehanna River.
This trail links to the Conestoga Trail System. Accessing House Rock Overlook: Follow the Conestoga Trail south from the trailhead on Bridge Valley Road approximately 1.4 miles to House Rock Overlook.
Hike at your own risk. The preserve is managed by the Lancaster County Conservancy.
Parking: Parking is limited in certain areas. Parking area available at the end of House Rock Road.
Accessing House Rock: Follow the Conestoga Trail south from the trailhead on Bridge Valley Road approximately 1.4 miles to House Rock Overlook.
Hike at your own risk. The preserve is managed by the Lancaster County Conservancy. Visit the Conservancy website at _URL_ to learn more about hiking, hunting, and parking conditions and any restrictions.
370 House Rock Rd, Pequea, PA 17565


Take the 2-minute tour ×
I am writing a package that saves information to an external file. I would like to name that file according to the source one; something like foo.tex -> foo.bar But I cannot find any variable that contains 'foo'. I am pretty sure that there must be one because the table of contents is saved to foo.toc.
Any pointers?
share|improve this question
For this purpose \jobname is always the right way to go. If you want to get the real main file name, which can be different from the job name if it is changed using the -jobname compiler argument, then see Macro to retrieve the real name of the source file if pdflatex is invoked with -jobname – Martin Scharrer May 8 '12 at 7:53
2 Answers 2
up vote 20 down vote accepted
You want the macro \jobname. This isn't quite the filename; to quote from the TeX FAQ:
TeX retains what it considers the name of the job, only, in the primitive \jobname; this is the name of the file first handed to TeX, stripped of its directory name and of any extension (such as.tex). If no file was passed (i.e., you're using TeX interactively), \jobname has the value texput (the name that's given to.log files in this case).
So if you're processing foo.tex, \jobname will be foo (which, of course, is probably what you want anyway).
share|improve this answer
Curiously, TeX does retain the current line number, see inputlineno – Yossi Gil Feb 28 '11 at 3:58
You are looking for \jobname.
EDIT: To add some value to my answer - pages 288-289 of the LaTeX2e sources contain the definition of \_USER_, the command that reads/writes ToC data from/to external files. This definition reveals the answer to your question.
share|improve this answer
Thank you for the link. It is always nice to have good sources. – Hector Dec 13 '10 at 1:33
Your Answer