---
layout: post
title: EuPathDB Scientific Working Group
category: [GiardiaDB]
---
EuPathDB is pleased to announce the members of the scientific working group
(SWG). The SWG provides EuPathDB with scientific oversight and
guidance. Members of the SWG also review the driving biological projects initiative.
| Michael Gottlieb, Chair Foundation for National Institutes of Health (FNIH) Broad expertise in parasitology, large integrative projects (chair) |
Matt Berriman Wellcome Trust Sanger Institute Pathogen genomics & functional annotation |
|
John Boothroyd Stanford University Toxoplasma biology & host-pathogen interactions |
Greg Buck Virginia Commonwealth University Pathogenomics of apicomplexan and kinetoplastid parasites |
|
Patrick Duffy National Institutes of Health (NIAID) Laboratory & clinical aspects of malaria biology |
Pascale Gaudet Northwestern University Biocuration, ontologies, DIctyostelium |
|
Adrian Hehl University of Zurich Cellular and molecular biology of Giardia |
Patrick Keeling University of British Columbia Comparative genomics |
|
Bill Petri University of Virginia Laboratory & clinical aspects of Entamoeba and diarrheal diseases |
Lincoln Stein Ontario Cancer Center Bioinformatics tools & analysis |
|
Lu Wang National Institutes of Health (NHGRI) Large-scale sequencing |
Jonathan Wastling University of Liverpool Proteomics of apicomplexan parasites |
|
Louis Weiss Albert Einstein College of Medicine Microsporidia, Toxoplasma, and clinical microbiology |
Dyann Wirth Harvard School of Public Health Plasmodium population biology, drug discovery |


Learn what makes a website.
This course is 3 weeks long. During each week, we will cover one module of the curriculum. These modules will consist of the following…
Prework will consist of information and exercises that will be helpful to your learning experience in tandem with the live sessions.  If there are sections of the prework that present difficulty to you, don’t worry! We can talk about problems in the Slack team for this course or during the live session. Just do the best you can for each prework section.
Practice problems will help you apply the concepts we are learning to challenges or projects. These problems will take place during the prework, but will be covered in varying degrees during our live sessions. Please keep in mind that the live session might not be able to cover the entirety of each practice problem, so it is still very important that you attempt these before each live session.
These practice problems are designed to be challenging and expose you to new coding concepts. It isn’t important that every solution you develop to be perfect. Instead, we are looking for you to dig into the problem, develop the best solution you can, articulate the areas in which you had difficulty, and communicate where you feel you are getting stuck.
These practice problems will also be added to your portfolio of work.
Live sessions will be where we work together to develop comprehension around key coding concepts. During these sessions, you will be coding together with an instructor and discussing key coding concepts.
Live sessions occur twice per week.
During labs you will work in small groups to develop weekly projects.
Labs will occur once per week.
You will be expected to turn in your various projects from throughout the week. All practice problems and larger projects will be submitted at 11:59pm on Thursday. These projects will be submitted by committing your code to GitHub (don’t worry if you don’t know what that is yet). Instructors will review your project code and provide feedback to you by the start of the following week.
Learning how to code can be a very rewarding experience, but it is also challenging. There will be times when you feel frustrated or lost, and we want you to know that is okay. There will also be parts of the learning process where you feel like you just don’t get it but it seems like everyone around you does. That is okay, too!
Everyone has different hangups when it comes to learning how to code. Some people have a difficult time with JavaScript, others will have a difficult time understanding how GitHub works, and others will have a very difficult time understanding databases. Code is a vast world and different parts of it sync well with different people.
This course will move fairly quickly and there are times when you might feel like you just don’t get it. Hang in there, ask questions, and use the resources we provide as well as the internet at large.
A helpful way to think about skills development is by referencing the Dunning-Kruger Effect.
Another way to think about the Dunning-Kruger Effect:


Back to christiansalvatore's blog
Awards
2017 "Forbes 30 Under 30 european Top Leaders, Inventors and Entrepeneurs of Tomorrow" Award assigned among more than 15000 candidates by The Forbes Magazine in the category "Science & HealthCare" for my research on Alzheimer’s Disease
link1 |
link2
2017 DSB Prize Assigned by the Department of Biomedical Sciences of the National Research Council of Italy (DSB-CNR) “in recognition of particularly significant results of research carried out in the field of biological and biomedical imaging”, for the project entitled "Artificial intelligence applied to biomedical imaging for the identification of new biomarkers for the early diagnosis and the prediction of neurological diseases”. Prize: 10.000,00 €
link
2017 Youth In Action Award for sustainable development goals Promoted and assigned by Fondazione Italiana Accenture, Fondazione Eni Enrico Mattei, and Fondazione Giangiacomo Feltrinelli “in recognition of the innovative, high social and technological impact that will help to achieve the Sustainable Development Goals in Italy”, for the project entitled “TRACE4AD: The RAdiologist's Cognitive Eyes for Alzheimer's Disease". Prize: 1,500,00 € and paid stage at "Fondazione Bracco" and "Centro Diagnostico Italiano". The project was also selected for an invited presentation at the Italian Parliament in Rome, during the closing of the Sustainable Development Festival (06/2017).
link
2017 Peres Heritage Initiative Award Assigned by the Peres Center for Peace & Innovation in partnership with The European House – Ambrosetti “to a young social innovator, entrepreneur or researcher who distinguished himself for the excellent results in fields consistent with the values promoted by Shimon Peres: pursuit of peace, green and circular economy, sustainability, inclusive business models, non-profit, social innovation, technological and scientific development, integration, new challenges in education”. The prize was awarded at The European House - Ambrosetti (Villa d'Este, Cernobbio, 09/2017), which hosts the initiative within the annual forum “Intelligence of the world, Europe, Italy" (1-3 september 2017). The winning project was presented in the presence of heads of state and government, ministers, Nobel prizes, entrepreneurs, managers and experts on issues of major impact for the global economy and society as a whole.
link1 |
link2
2017 Civic Merit assigned by the Municipality of Nova Milanese “For the prestigious national and international results in scientific research”.
2017 Angelo Marai Prize (V edition) Assigned by ASIS (assegnato da ASIS (Assosiaction of Studies on the Health Industry) and Carlo Erba Foundation to a PhD who, during his/her doctoral studies, carried out particularly innovative research which may constitute a basis for future programs in the field of neurodegenerative diseases. Prize: 2.500,00 €.


mlock, mlock2, munlock, mlockall, munlockall - lock and unlock memory
#include <sys/mman.h>
int mlock(const void *addr, size_t len);
int mlock2(const void *addr, size_t len, int flags);
int munlock(const void *addr, size_t len);
int mlockall(int flags);
int munlockall(void);
mlock(), mlock2(), and mlockall() lock part or all of the
calling process's virtual address space into RAM, preventing that memory from
being paged to the swap area.
munlock() and munlockall() perform the converse
operation, unlocking part or all of the calling process's virtual address
space, so that pages in the specified virtual address range may once more to
be swapped out if required by the kernel memory manager.
Memory locking and unlocking are performed in units of whole
pages.
mlock() locks pages in the address range starting at addr and
continuing for len bytes. All pages that contain a part of the
specified address range are guaranteed to be resident in RAM when the call
returns successfully; the pages are guaranteed to stay in RAM until later
unlocked.
mlock2() also locks pages in the specified range starting
at addr and continuing for len bytes. However, the state of
the pages contained in that range after the call returns successfully will
depend on the value in the flags argument.
The flags argument can be either 0 or the following
constant:
- MLOCK_ONFAULT
- Lock pages that are currently resident and mark the entire range so that
the remaining nonresident pages are locked when they are populated by a
page fault.
If flags is 0, mlock2() behaves exactly the same as
mlock().
munlock() unlocks pages in the address range starting at
addr and continuing for len bytes. After this call, all pages
that contain a part of the specified memory range can be moved to external
swap space again by the kernel.
mlockall() locks all pages mapped into the address space of the calling
process. This includes the pages of the code, data and stack segment, as well
as shared libraries, user space kernel data, shared memory, and memory-mapped
files. All mapped pages are guaranteed to be resident in RAM when the call
returns successfully; the pages are guaranteed to stay in RAM until later
unlocked.
The flags argument is constructed as the bitwise OR of one
or more of the following constants:
- MCL_CURRENT
- Lock all pages which are currently mapped into the address space of the
process.
- MCL_FUTURE
- Lock all pages which will become mapped into the address space of the
process in the future. These could be, for instance, new pages required by
a growing heap and stack as well as new memory-mapped files or shared
memory regions.
- MCL_ONFAULT (since Linux 4.4)
- Used together with MCL_CURRENT, MCL_FUTURE, or both. Mark
all current (with MCL_CURRENT) or future (with MCL_FUTURE)
mappings to lock pages when they are faulted in. When used with
MCL_CURRENT, all present pages are locked, but mlockall()
will not fault in non-present pages. When used with MCL_FUTURE, all
future mappings will be marked to lock pages when they are faulted in, but
they will not be populated by the lock when the mapping is created.
MCL_ONFAULT must be used with either MCL_CURRENT or
MCL_FUTURE or both.
If MCL_FUTURE has been specified, then a later system call
(e.g., mmap(2), sbrk(2), malloc(3)), may fail if it
would cause the number of locked bytes to exceed the permitted maximum (see
below). In the same circumstances, stack growth may likewise fail: the
kernel will deny stack expansion and deliver a SIGSEGV signal to the
process.
munlockall() unlocks all pages mapped into the address
space of the calling process.
On success, these system calls return 0. On error, -1 is returned, errno
is set appropriately, and no changes are made to any locks in the address
space of the process.
- ENOMEM
- (Linux 2.6.9 and later) the caller had a nonzero RLIMIT_MEMLOCK
soft resource limit, but tried to lock more memory than the limit
permitted. This limit is not enforced if the process is privileged
(CAP_IPC_LOCK).
- ENOMEM
- (Linux 2.4 and earlier) the calling process tried to lock more than half
of RAM.
- EPERM
- The caller is not privileged, but needs privilege (CAP_IPC_LOCK) to
perform the requested operation.
For mlock(), mlock2(), and munlock():
- EAGAIN
- Some or all of the specified address range could not be locked.
- EINVAL
- The result of the addition addr+len was less than
addr (e.g., the addition may have resulted in an overflow).
- EINVAL
- (Not on Linux) addr was not a multiple of the page size.
- ENOMEM
- Some of the specified address range does not correspond to mapped pages in
the address space of the process.
- ENOMEM
- Locking or unlocking a region would result in the total number of mappings
with distinct attributes (e.g., locked versus unlocked) exceeding the
allowed maximum. (For example, unlocking a range in the middle of a
currently locked mapping would result in three mappings: two locked
mappings at each end and an unlocked mapping in the middle.)
For mlock2():
- EINVAL
- Unknown flags were specified.
For mlockall():
- EINVAL
- Unknown flags were specified or MCL_ONFAULT was specified
without either MCL_FUTURE or MCL_CURRENT.
For munlockall():
- EPERM
- (Linux 2.6.8 and earlier) The caller was not privileged
(CAP_IPC_LOCK).
mlock2() is available since Linux 4.4; glibc support was added in version
2.27.
POSIX.1-2001, POSIX.1-2008, SVr4.
mlock2 () is Linux specific.
On POSIX systems on which mlock() and munlock() are available,
_POSIX_MEMLOCK_RANGE is defined in <unistd.h> and the
number of bytes in a page can be determined from the constant PAGESIZE
(if defined) in <limits.h> or by calling
sysconf(_SC_PAGESIZE).
On POSIX systems on which mlockall() and
munlockall() are available, _POSIX_MEMLOCK is defined in
<unistd.h> to a value greater than 0. (See also
sysconf(3).)
Memory locking has two main applications: real-time algorithms and high-security
data processing. Real-time applications require deterministic timing, and,
like scheduling, paging is one major cause of unexpected program execution
delays. Real-time applications will usually also switch to a real-time
scheduler with sched_setscheduler(2). Cryptographic security software
often handles critical bytes like passwords or secret keys as data structures.
As a result of paging, these secrets could be transferred onto a persistent
swap store medium, where they might be accessible to the enemy long after the
security software has erased the secrets in RAM and terminated. (But be aware
that the suspend mode on laptops and some desktop computers will save a copy
of the system's RAM to disk, regardless of memory locks.)
Real-time processes that are using mlockall() to prevent
delays on page faults should reserve enough locked stack pages before
entering the time-critical section, so that no page fault can be caused by
function calls. This can be achieved by calling a function that allocates a
sufficiently large automatic variable (an array) and writes to the memory
occupied by this array in order to touch these stack pages. This way, enough
pages will be mapped for the stack and can be locked into RAM. The dummy
writes ensure that not even copy-on-write page faults can occur in the
critical section.
Memory locks are not inherited by a child created via
fork(2) and are automatically removed (unlocked) during an
execve(2) or when the process terminates. The mlockall()
MCL_FUTURE and MCL_FUTURE | MCL_ONFAULT settings are not
inherited by a child created via fork(2) and are cleared during an
execve(2).
Note that fork(2) will prepare the address space for a
copy-on-write operation. The consequence is that any write access that
follows will cause a page fault that in turn may cause high latencies for a
real-time process. Therefore, it is crucial not to invoke fork(2)
after an mlockall() or mlock() operation—not even from
a thread which runs at a low priority within a process which also has a
thread running at elevated priority.
The memory lock on an address range is automatically removed if
the address range is unmapped via munmap(2).
Memory locks do not stack, that is, pages which have been locked
several times by calls to mlock(), mlock2(), or
mlockall() will be unlocked by a single call to munlock() for
the corresponding range or by munlockall(). Pages which are mapped to
several locations or by several processes stay locked into RAM as long as
they are locked at least at one location or by at least one process.
If a call to mlockall() which uses the MCL_FUTURE
flag is followed by another call that does not specify this flag, the
changes made by the MCL_FUTURE call will be lost.
The mlock2() MLOCK_ONFAULT flag and the
mlockall() MCL_ONFAULT flag allow efficient memory locking for
applications that deal with large mappings where only a (small) portion of
pages in the mapping are touched. In such cases, locking all of the pages in
a mapping would incur a significant penalty for memory locking.
Under Linux, mlock(), mlock2(), and munlock() automatically
round addr down to the nearest page boundary. However, the POSIX.1
specification of mlock() and munlock() allows an implementation
to require that addr is page aligned, so portable applications should
ensure this.
The VmLck field of the Linux-specific
/proc/[pid]/status file shows how many kilobytes of memory the
process with ID PID has locked using mlock(), mlock2(),
mlockall(), and mmap(2) MAP_LOCKED.
In Linux 2.6.8 and earlier, a process must be privileged (CAP_IPC_LOCK)
in order to lock memory and the RLIMIT_MEMLOCK soft resource limit
defines a limit on how much memory the process may lock.
Since Linux 2.6.9, no limits are placed on the amount of memory
that a privileged process can lock and the RLIMIT_MEMLOCK soft
resource limit instead defines a limit on how much memory an unprivileged
process may lock.
In Linux 4.8 and earlier, a bug in the kernel's accounting of locked memory for
unprivileged processes (i.e., without CAP_IPC_LOCK) meant that if the
region specified by addr and len overlapped an existing lock,
then the already locked bytes in the overlapping region were counted twice
when checking against the limit. Such double accounting could incorrectly
calculate a "total locked memory" value for the process that
exceeded the RLIMIT_MEMLOCK limit, with the result that mlock()
and mlock2() would fail on requests that should have succeeded. This
bug was fixed in Linux 4.9
In the 2.4 series Linux kernels up to and including 2.4.17, a bug
caused the mlockall() MCL_FUTURE flag to be inherited across a
fork(2). This was rectified in kernel 2.4.18.
Since kernel 2.6.9, if a privileged process calls
mlockall(MCL_FUTURE) and later drops privileges (loses the
CAP_IPC_LOCK capability by, for example, setting its effective UID to
a nonzero value), then subsequent memory allocations (e.g., mmap(2),
brk(2)) will fail if the RLIMIT_MEMLOCK resource limit is
encountered.
mincore(2), mmap(2), setrlimit(2), shmctl(2),
sysconf(3), proc(5), capabilities(7)
This page is part of release 5.05 of the Linux man-pages project. A
description of the project, information about reporting bugs, and the latest
version of this page, can be found at https://www.kernel.org/doc/man-pages/.


--- layout: page title: About subtitle: 'Me & the site' favicon: favicon-rebel.ico ---
I'm André Vieira, a data scientist and R-Shiny consultant passionate about building web apps to better communicate data-driven findings. I'm a PhD candidate in Sociology at Federal University of Rio de Janeiro, working on modeling social inequalities and mobility.
Use machine learning techniques, with a focus on regression and classification, to automatically identify patterns in your data and make better predictions.
Communicating empirical findinds is really about telling a good story. Strong and relevant illustrations have the power to make analysis clear and drive home your message.
There is no single way of understanding the world. And no approach is perfect. I enjoy teaching how sociology can help us understand how things really work.
Science is necessarily a collective undertaking. And I've learned a lot by working with other people. Code reviewing and optimization is a fundamental part of that.
This site is powered by Jekyll using a custom Strange Case theme. The template was larlegy inspired by Joshua Kunst website.
The R blog posts are compiled with knitr R markdown using this script. You can find the reproducible sources of each blog post here.


Masonry gallery demo
For Angular 14 and beyond
Installation
Module inicialization
Usage
Configuration
| Property |
Type |
Description |
| width |
number |
Width of the column in pixels |
| gutter |
number |
Size of gutter between columns in pixels |
| verticalGutter |
number |
Size of the gutter between particular items in pixels. Can be combined with gutter to create all around gutter. |
| imageClasses |
string[] |
Array of classes added to images for custom styling |
Methods
| Method |
Input |
Description |
| addImages |
IMasonryGalleryImage[] |
Adds given images to gallery |
| removeImages |
IMasonryGalleryImage[] |
Removes selected images from gallery |
Events
| Event |
Type |
Description |
| clickImage |
Output |
Executes when an image is clicked.
IMasonryGalleryImage is passed to event. |
| layoutComplete |
Output |
See layoutComplete. Contains layout items. |
| removeComplete |
Output |
See removeComplete. Contains removed items. |


Poppy, the silly man from Elm Springs, ran into Pip's cabin and said with a gasp, "I invented a rabbit-truck!" Pip sat up in bed, and said, "A what?" The old man led him to his lab, and in the back was a big red truck...with legs. The legs were metal, with long springs. Poppy got in and hit the gas, and the truck left the lab with one big rabbit hop.
in-context


This is an automated courtesy notification from the Idaho Sexual Assault Kit Tracking System (IKTS).
Sexual assault kit #${kitSerialNumber} is recorded in the system as having been in the possession of your law enforcement agency for ${daysAtLawEnforcement} days. Section 67-2919 of Idaho Code requires sexual assault kits to be submitted to the Idaho State Police Forensic Services laboratory for testing within 30 days of receipt by a law enforcement agency, unless:
If sexual assault kit #${kitSerialNumber} meets one of the three criteria above, please update the status in IKTS immediately so the prosecutor can review the decision to not have the sexual assault kit tested. Otherwise, please contact the Idaho State Police Forensic Services laboratory in Meridian as soon as possible at<PHONE_NUMBER> to arrange for submission of the sexual assault kit #${kitSerialNumber} and associated known reference samples. If a required known reference sample is unavailable please contact the laboratory at<PHONE_NUMBER> prior to submission to discuss the situation.
If you believe the information in this email is incorrect, or you have further questions regarding this issue, please contact the IKTS Administrator at or call<PHONE_NUMBER>.


Circle of Moment Measurement: 7/18 – 19
20 Jun 2015, by Taeyoon ChoiWhat is time really? As humanity, we collectively agree on using Universal Time as a standard to keep things in order in an increasingly synchronized and complex society. However, is it the only way to measure your time on this earth? What if we re-design time based off of your perception of moments?
By being part of the Circle of Moment Measurement, you will collectively agree to all live by different times. Everyone in this participatory performance will discover their own personalized speed of time that is kept in portable and networked timekeeping devices, designed by the artists with support of LACMA Art + Technology Lab.
In this participatory performance, there will be a chance to experience the public spaces in LACMA in your own time. After that a conversation about how the new forms of time measurement would affect life would follow, as well as a opportunity to share the experience with the world.
This is a half-day event, led by the artists, requires about a four-hour time commitment. The afternoon concludes with video interviews documenting the experience and a group discussion about how alternative time measurement might affect daily life.
—
Circle of Moment Measurement
7/18-19, 2015, 1–5pm
LACMA, Art + Technology Lab
Art of the Americas Building
5905 Wilshire Boulevard, Los Angeles, CA 90036
7/18 – PRIVATE BETA
1pm – 5 pm
The first event is a private, invitation-only event for artists' collaborators and the community around the Art + Technology Lab. Request for an invitation here.
7/19 – OPEN TO PUBLIC
1pm – 5pm
The public event Circle of Moment Measurement is the final component of In Search of Personalized Time. More information and sign up on LACMA's event page.


This is the official AtomicDEX mobile beta program channel -
Android: https://play.google.com/store/apps/details?id=com.komodoplatform.atomicdex - iOS: https://testflight.apple.com/join/c2mOLEoC - Please use https://github.com/KomodoPlatform/atomicdex/issues for bug reports and feature requests. For critical security bug reports please do send us your encrypted (https://pgp.mit.edu/pks/lookup?op=get&search=0x379287998EE6CF47) report to<EMAIL_ADDRESS>and allow up to 24h for reply. For atomicDEX API (mm2) related issue reports or feature requests please do use https://github.com/KomodoPlatform/atomicDEX-API/issues
100 messages
Before 05-Dec-19 12:00 AM
Slyris19-Jul-19 09:29 AM
@ca333 There is the possibility inside the app to see the version of the app that we are running ?
TonyL19-Jul-19 09:30 AM
Yes, I'm tracking this channel all the time when with PC
Slyris19-Jul-19 09:30 AM
For example the build number or the version
TonyL19-Jul-19 09:30 AM
@Slyris it's possible to see in settings menu on the bottom
In new release will be also possible to see which mm2 version bundled
Slyris19-Jul-19 09:30 AM
i dont have this information in my version at the bottom of settings menu
TonyL19-Jul-19 09:32 AM
Ouch, so both will be displayed in new release
Have new one on my phone already
Slyris19-Jul-19 09:32 AM
It's for reporting an issue, so i can specify the version i'm running
TonyL19-Jul-19 09:33 AM
For now you can check app version in your phone applications management menu - in next release it will be visible on the bottom of settings menu
Slyris19-Jul-19 09:33 AM
0.1.3 i see
Thank's
1
ca33319-Jul-19 09:35 AM
@Slyris thats a local issue on your end
delete your app (clean)
and reinstall the latest versoin
afterwards check settings page again
Slyris19-Jul-19 09:35 AM
Will do that now.
1
Yeah i saw it now, thank's @ca333. I had just reinstall the application without uninstalling it. Now i saw it
1
When you uninstall the application. The history of your transactions disappears logically. That's why I think that the export of data is super important or even the possibility of link a google drive for example to record in pdf format our transactions.
The user could configure his application so that every month the history of his transactions is automatically exported to his drive in a secure way.
TonyL19-Jul-19 09:42 AM
@Simon is only password hint place you noticed so far where text doens't fit on IphoneSE?
ca33319-Jul-19 09:43 AM
TX export coming soon @Slyris - we have this already noted in the 'future features' - even for specific timeframes, etc.
For swaps we will think about a method to persist trades (unless a user wants to delete them) too.
Slyris19-Jul-19 09:43 AM
It's super cool, that's really something that customers are looking for. @ca333
1
ca33319-Jul-19 09:43 AM
The feature additions we will start working on in approx. 2-3 weeks.
Slyris19-Jul-19 09:43 AM
Glad to hear
I suppose the addition of some chart based on our portfolio is planned?
"it means that if you trade 1 ETH by this rate (1 KMD = 0.005 ETH) you'll get 43000 USD of value for 1 ETH" real value should be 200 dollars though
Not 43000
I mean 200 KMD which is like 240 dollar or something
TonyL19-Jul-19 10:01 AM
Hmm, yes - thats fair point So looks like a visual price displaying bug in cases when there is no orders for market and you create new one. Let me create an issue
On screenshot: input for trade 0.05 ETH for 10 KMD
What means 1 KMD = 0.005 ETH rate, or 1 ETH = 200 KMD
In USD equivalent should be ~242$ (with KMD by 1.21$). So it seems this USD amount calculating not correct.
!image
I kept trying to put my full amount of Rick up for swap Enter details for initial swap amounts Proceed to next screen Go back This allows you to enter a coin amount on the first line without select...
benzo36519-Jul-19 11:29 AM
Was doing this swap, did not confirm, jumped to another app and came back about 15 secs later, authenticated and then red screen of death
TonyL19-Jul-19 11:34 AM
Thank you! Not able to reproduce this way on current release candidate - so maybe this issue is already fixed
1
benzo36519-Jul-19 12:01 PM
Is there a request in for 'sell all' when doing a swap? Instead of having to go back and check how much you have?
TonyL19-Jul-19 12:03 PM
yes, "max" button to sell all balance will presist in next release
For now the history of swaps is only local. So if you change a device etc.. you will not have the swap history. So for now it's not possible to do this.
jl777c19-Jul-19 01:50 PM
seems that exporting only local history is sufficient @Kiruel
most people will just use one phone and if they need to get all their history, they would just need to export from each phone used. we dont want to get into aggregating histories from multiple devices
Kiruel19-Jul-19 01:51 PM
Do you think it's possible to get all history swaps from a public key ? (in the future i mean)
Exporting in local it's simple, but i think something more accurate.
jl777c19-Jul-19 01:52 PM
that would be accurate enough as long as people dont delete things
Slyris19-Jul-19 01:52 PM
You can propose and export in a JSON format that is linked to a drive and when you restore you use the JSON information
jl777c19-Jul-19 01:53 PM
maybe if there is some centralized stats website, it could figure out all the swaps, but that will be very tricky


Customer name: --
Address: --
Contact number: --
Email address: --
Date & Time: --
Status: --
Employee name: --


General
Using DbUnit
Errors
See the publicly maintained list of compatible RDBMS at the DbUnit Wiki. Don't hesitate to contribute to this list, particularly for databases not listed yet.
Cf. Building DbUnit detailed instruction.
No. DbUnit is not intended to track or test structural DB changes. For this purpose check out liquibase.
P6Spy is a transparent JDBC proxy-driver which log the statements performed against the actual driver you normally would use. Using p6spy allows to log the SQL statements issued by DbUnit.
To install P6Spy, complete the following steps:
Look at Changes Report and at Issue Tracking.
The following sample demonstrates how you can export one or many tables from a database to a flat XML dataset file. Note that if you want to specify a schema you can do this in the constructor of DatabaseConnection.
public class DatabaseExportSample { public static void main(String[] args) throws Exception { // database connection Class driverClass = Class.forName("org.hsqldb.jdbcDriver"); Connection jdbcConnection = DriverManager.getConnection( "jdbc:hsqldb:sample", "sa", ""); IDatabaseConnection connection = new DatabaseConnection(jdbcConnection); // partial database export QueryDataSet partialDataSet = new QueryDataSet(connection); partialDataSet.addTable("FOO", "SELECT * FROM TABLE WHERE COL='VALUE'"); partialDataSet.addTable("BAR"); FlatXmlDataSet.write(partialDataSet, new FileOutputStream("partial.xml")); // full database export IDataSet fullDataSet = connection.createDataSet(); FlatXmlDataSet.write(fullDataSet, new FileOutputStream("full.xml")); // dependent tables database export: export table X and all tables that // have a PK which is a FK on X, in the right order for insertion String[] depTableNames = TablesDependencyHelper.getAllDependentTables( connection, "X" ); IDataSet depDataset = connection.createDataSet( depTableNames ); FlatXmlDataSet.write(depDataSet, new FileOutputStream("dependents.xml")); } }
The following sample demonstrates how you can generate a flat xml dataset DTD from a database.
public class DatabaseExportSample { public static void main(String[] args) throws Exception { // database connection Class driverClass = Class.forName("org.hsqldb.jdbcDriver"); Connection jdbcConnection = DriverManager.getConnection("jdbc:hsqldb:sample", "sa", ""); IDatabaseConnection connection = new DatabaseConnection(jdbcConnection); // write DTD file FlatDtdDataSet.write(connection.createDataSet(), new FileOutputStream("test.dtd")); } }
Note that there is a more flexible possibility to write out a DTD which allows you to vary the content model of the DTD:
... IDataSet dataSet = connection.createDataSet(); Writer out = new OutputStreamWriter(new FileOutputStream("myFile.dtd"); FlatDtdWriter datasetWriter = new FlatDtdWriter(out); datasetWriter.setContentModel(FlatDtdWriter.CHOICE); // You could also use the sequence model which is the default // datasetWriter.setContentModel(FlatDtdWriter.SEQUENCE); datasetWriter.write(dataSet);
Many RDBMSes allow IDENTITY and auto-increment columns to be implicitly overwritten with client values.
DbUnit can be used with these RDBMS natively. Some databases, like MS SQL Server and Sybase,
need to explicitly activate client values writing. The way to activate this feature is vendor-specific.
DbUnit provides this functionality for MS SQL Server with the
InsertIdentityOperation class.
See FlatXmlDataSet documentation
Yes. By default DbUnit is configured to only recognize normal tables. Modify the table type property to work with other table types. For example, use {"TABLE", "VIEW"} for views.
Be aware that REFRESH, DELETE and UPDATE operations are not compatible with tables without primary keys. They are not usable with views without overriding primary keys detection. CLEAN_INSERT, INSERT and DELETE_ALL operations are compatible with views.
DbUnit use the JDBC escape formats for string representation.
| Type | Format |
|---|---|
| DATE | yyyy-mm-dd |
| TIME | hh:mm:ss |
| TIMESTAMP | yyyy-mm-dd hh:mm:ss.fffffffff |
You can replace the default DbUnit data type factory to get support for custom data types. DbUnit provides extended factories for some vendors, which are located in org.dbunit.ext subpackages.
Here is how to setup the Oracle factory:
IDatabaseConnection connection = new DatabaseConnection(jdbcConnection, schema); DatabaseConfig config = connection.getConfig(); config.setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, new OracleDataTypeFactory());
Don't hesitate to submit your own implementation if you encounter types not currently supported by DbUnit.
Historically, DbUnit has had memory consumption issues when working with very large dataset files. DbUnit 2.0 includes many improvements, like using SAX2 instead of the Electric XML parser and streamed XML dataset writing, to overcome the memory consumption problems.
For compatibility reason, streamed export and import are not enabled by default. When working with large dataset, using this feature can make a huge difference.
Configure your DbUnit connection to use ForwardOnlyResultSetTable when exporting very large dataset. ForwardOnlyResultSetTable is a very efficient database table implememtation, useful when random data access is not required. By default, DbUnit uses CachedResultSetTable which consume more memory but provides random data access.
Following sample shows how to configure your DbUnit connection to use ForwardOnlyResultSetTable:
IDatabaseConnection connection = new DatabaseConnection(jdbcConnection, schema); DatabaseConfig config = connection.getConfig(); config.setProperty(DatabaseConfig.PROPERTY_RESULTSET_TABLE_FACTORY, new ForwardOnlyResultSetTableFactory());
Use the very efficient StreamingDataSet to load your XML dataset when working with forward only database operations like UPDATE, INSERT, REFRESH.
Flat XML validation is disabled by default even if you are using a DTD. Following sample demonstrate how to load a flat XML dataset with DTD validation enabled:
FlatXmlProducer producer = new FlatXmlProducer(new InputSource("dataset.xml")); producer.setValidating(true); IDataSet dataSet = new CachedDataSet(producer);
It is normal that testing with a real database is slower than testing with MockObjects. Here are few tricks that will help to speed up your DbUnit tests.
Creating a new DbUnit connection every time has a cost. The overhead is much more than just creating a new JDBC connection. DbUnit needs to fetch the metadata of tables to retrieve the column data types. This information is cached in the DbUnit connection. So it is highly recommended to reuse the same DbUnit connection throughout your test suite; the more tables you have, the greater the benefits.
If your database server supports multiple schemas, like Oracle, you should always specify the schema name you want to use when creating the DbUnit connection. DbUnit can potentially fetch the metadata of all tables it has access to. This includes tables from other schemas if you are using a god JDBC connection. So in this situation, specifying a schema name can dramatically improve DbUnit performance.
Unit testing requires relatively little data. So try to keep your setup datasets as small as possible. There is no necessity to reset the entire database content at the beginning of every test. Try to use only the data you need for a particular test case.
If most of your tests are using the same read-only data, you should consider initializing this data once for an entire test class or test suite.
The batched statements feature is disabled by default because there are many JDBC drivers incompatible with it. It is recommended to enable this feature if your driver supports it. The performance gain may not be very significant when testing with small datasets, though.
IDatabaseConnection conn = new DatabaseConnection(jdbcConn); ITableFilter filter = new DatabaseSequenceFilter(conn); IDataSet dataset = new FilteredDataSet(filter, conn.createDataSet()); FlatXmlDataSet.write(dataset, new File(fileName));
Use the setDocType() method of the FlatXmlWriter class like this:
FlatXmlWriter datasetWriter = new FlatXmlWriter(new FileOutputStream("dataset.xml")); datasetWriter.setDocType("dataset.dtd"); datasetWriter.write(connection.createDataSet());
The FilteredTableMetaData class introduced in DbUnit 2.1 can be used in combination with the IColumnFilter interface to decide the inclusion or exclusion of table columns at runtime.
FilteredTableMetaData metaData = new FilteredTableMetaData(originalTable.getTableMetaData(), new MyColumnFilter()); ITable filteredTable = new CompositeTable(metaData, originalTable);
You can use your own IColumnFilter implementation or use the DefaultColumnFilter
class provided by DbUnit. DefaultColumnFilter supports wildcards. This class also offers
some convenience methods, includedColumnsTable() and excludedColumnsTable(), to ease creation of column filtered table.
The following sample demonstrates the usage of DefaultColumnFilter to exclude all columns prefixed with "PK" or suffixed by "TIME".
DefaultColumnFilter columnFilter = new DefaultColumnFilter(); columnFilter.excludeColumn("PK*"); columnFilter.excludeColumn("*TIME"); FilteredTableMetaData metaData = new FilteredTableMetaData(originalTable.getTableMetaData(), columnFilter);
Same than above but using the excludedColumnsTable() convenience method.
ITable filteredTable = DefaultColumnFilter.excludedColumnsTable(originalTable, new String[]{"PK*", "*TIME"});
See also Ignoring some columns in comparison.
By implementing the interface IRowFilter it is possible to query column values and to return either true if this row should be accepted or false if it should be filtered out.
IRowFilter rowFilter = new IRowFilter() { public boolean accept(IRowValueProvider rowValueProvider) { Object columnValue = rowValueProvider.getColumnValue("COLUMN1"); if(((String)columnValue).equalsIgnoreCase("customerAbroad")) { return true; } return false; } }; ITable filteredTable = new RowFilterTable(iTable, rowFilter);
The DefaultDataTypeFactory provides the method "addToleratedDelta()" to define an allowed deviation of the compared values for a specific database column.
DefaultDataTypeFactory datatypeFactory = new OracleDataTypeFactory(); datatypeFactory.addToleratedDelta(new ToleratedDelta("TEST_TABLE", "COLUMN0", 0.0001)); // Set the datatype factory DatabaseConnection dbConnection = new DatabaseConnection(jdbcConnection); dbConnection.getConfig().setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, datatypeFactory);
There is a method assertEquals(ITable expectedTable, ITable actualTable, Column[] additionalColumnInfo) that allows to specify additional columns as third parameter. If two rows are not equal the values of the given columns are printed out in the assertion text.
Assertion.assertEquals(iTableExpected, iTableActual, new Column[] {new Column("COLUMN0", DataType.VARCHAR)} );
The IColumnFilter interface is now used by InsertIdentityOperation to detect identity columns. The default implementation assumes that type name of identity columns end with "identity". If you are using user defined types that does not follow this assumption you can now provide your own implementation via the MS SQL identity column filter property.
IDatabaseConnection connection = new DatabaseConnection(jdbcConnection); connection.getConfig().setProperty( "http://www.dbunit.org/properties/mssql/identityColumnFilter", new MyIndentityFilter());
The IColumnFilter interface can also be used to determine which columns are primary keys instead of using DatabaseMetaData.getPrimaryKeys(). This can be useful if your primary keys are not explicitly defined in your database model.
IDatabaseConnection connection = new DatabaseConnection(jdbcConnection); connection.getConfig().setProperty( "http://www.dbunit.org/properties/primaryKeyFilter", new MyPrimaryKeyFilter());
DbUnit uses the first tag for a table to define the columns to be populated. If the following records for this table contain extra columns, these ones will therefore not be populated. To solve this, either define all the columns of the table in the first row (using NULL values for the empty columns), or use a DTD to define the metadata of the tables you use.
Since DBUnit 2.3.0 there is a functionality called "column sensing" which basically reads in the whole XML into a buffer and dynamically adds new columns as they appear. It can be used as demonstrated in the following example:
//Since release 2.4.7 we use a builder: FlatXmlDataSetBuilder builder = new FlatXmlDataSetBuilder(); builder.setColumnSensing(true); IDataSet dataSet = builder.build(new File("src/xml/flatXmlTableTest.xml"));
//This is for release < 2.4.7boolean enableColumnSensing = true; IDataSet dataSet = new FlatXmlDataSet(new File("src/xml/flatXmlTableTest.xml"), false, enableColumnSensing);
The simplest way is to use the ReplacementTable/ReplacementDataSet.
ITable actualTable = ... // Load actual table from database or somewhere else ITable table = new XmlDataSet(new FileInputStream("myFile.xml")).getTable("TABLE"); ReplacementTable replacementTable = new ReplacementTable(table); replacementTable.addReplacementObject("special-now", new java.util.Date(System.currentTimeMillis())); Assertion.assertEquals(replacementTable, actualTable);
You can easily extend the XmlDataSet class and overwrite the methods that write the string values as follows:
public class MyXmlWriter extends org.dbunit.dataset.xml.XmlDataSetWriter { ... protected void writeValueCData(String stringValue) throws IOException { int k = 0; while((k = str.indexOf('\r')) != -1){ getXmlWriter().writeCData(str.substring(0, k)); getXmlWriter().writeText("\r", true); str = str.substring(k + 1); } getXmlWriter().writeCData(str); } protected void writeValue(String stringValue) throws IOException { // Write literally super.getXmlWriter().writeText(stringValue, true); } }
Since DBUnit 2.4.4 there is a new method IDatabaseTester#setOperationListener which allows to set a user defined listener which is invoked on different operations during the test execution. The DBTestCase/DatabaseTestCase classes make use of this new functionality and by default closes the connection after setUp/tearDown operations were executed. Here an example of how to change this behavior so that the connection will not be closed anymore:
public class MyTestCase extends DBTestCase{ // Overwrite the method getOperationListener to provide our own operation listener protected IOperationListener getOperationListener() { return new DefaultOperationListener(){ public void operationSetUpFinished( IDatabaseConnection connection) { // Do not invoke the "super" method to avoid that the connection is closed } public void operationTearDownFinished( IDatabaseConnection connection) { // Do not invoke the "super" method to avoid that the connection is closed } }; } }
public class MyTestCase extends DBTestCase{ // Overwrite the method getOperationListener to provide our own operation listener protected IOperationListener getOperationListener() { return IOperationListener.NO_OP_OPERATION_LISTENER; } }
... IDatabaseTester dbTester = new DataSourceDatabaseTester(ds); dbTester.setOperationListener(IOperationListener.NO_OP_OPERATION_LISTENER) dbTester.onSetup(); ...
There is limited support for postgresql enums because only reading and writing strings is supported since dbunit 2.4.6. To do so you have to override the method "isEnumType" in the PostgresqlDataTypeFactory like this:
PostgresqlDataTypeFactory factory = new PostgresqlDataTypeFactory(){ public boolean isEnumType(String sqlTypeName) { if(sqlTypeName.equalsIgnoreCase("abc_enum")){ return true; } return false; } };
This warning occurs when no data type factory has been configured and DbUnit defaults to its org.dbunit.dataset.datatype.DefaultDataTypeFactory which supports a limited set of RDBMS.
You can solve this problem in two different ways:
This error occurs when no schema is specified and that DbUnit detect that it is getting columns information from multiple tables having the same name and located in different schemas.
You can solve this problem in three different ways:
By default, DbUnit only supports standard JDBC data types. You are getting this warning message if you are using vendor-specific data types.
Read how to replace the default data type factory and how to disable this warning message.
If you are using the Microsoft driver (i.e. com.microsoft.sqlserver.jdbc.SQLServerDriver), you need to use the SelectMethod=cursor parameter in the JDBC connection string (as outlined by this JDBC thread). Your database Url would look something like:
jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb;SelectMethod=cursor
DbUnit uses JDBC 2.0 features (batch updates). By default, DB2 installs the JDBC 1.0 driver. You have to install the JDBC 2.0 driver for DbUnit to work, or you will get an UnsatisfiedLinkError from the DB2 JDBC 1.0 driver.
The steps for installing the DB2 JDBC 2.0 driver are covered in the DB2 documentation.
Since version 2.2.1, DbUnit uses SLF4J for logging purposes (See dependencies). You must therefore download SLF4J and include slf4j-api-*.jar and the jar corresponding to your favourite logging library in your classpath (e.g. slf4j-log4j12-*.jar for Log4j or slf4j-jcl-*.jar for commons-logging). See the SLF4J homepage for more details.
Please make sure there is only one slf4j implementation library in your classpath. In particular, jcl104-over-slf4j-*.jar and slf4j-jcl-*.jar must not be used together
This exception can occur especially with MySQL RDBMS if you forget to set the special MySqlMetadataHandler on the DatabaseConfig. See properties page for more.


Displaying a Sound File
How to display a sound file using the Media module. The Media module displays controls with play, pause, rewind, volume and other buttons enabling users to manage the sound. Sound file types include mp3, mwa, etc. Note: If the video or Flash is located on your site, you may need the Host to enable you to upload some file types.
- Select Edit Media Options from the module actions menu.
- Expand the Specify Your Media section.
- At Media Type, select Standard File System.
- At File Location/Link Type select either a URL or File link to the sound file. See "Setting a URL Link", See "Setting a File Link", or See "Uploading and Linking to a File"
- In the Alternate Text text box, enter alternative text to describe the sound file. This text is not displayed on the module.
- Expand the Basic Settings section.
- Required. In the Width text box, enter the pixel number to set the length of the sound file control panel. If no value is entered, the width will default to 0 (zero) and the sound file control panel will not be accessible.
- Required. In the Height text box, enter a pixel number to set the height of the sound file control panel. If no value is entered, the height will default to 0 (zero) and the sound file control panel will not be accessible.
- Optional. In the Description of the Media Editor, enter and format the text to be displayed below this image.
- Optional. At Media Alignment, select either None, Left, Center or Right to set the alignment of the image. If no option is selected the default setting Use Module Settings Value is used.
- Expand the Social Integration section and set the following:
-
At Post To Journal, to post details of this media to your Journal - OR - Unto add the media without posting to your Journal. Note: If this setting has been pre-set by an Administrator for all Media modules on this site, then you will be prevented from changing this setting without first checking the "Override Site Settings" check box below.
- At Override Site Settings, to override the site wide settings for Media modules that has been set by an Administrator - OR - Unto use the site wide settings.
-
Click the Update button.
Displaying a Sound File
A sound file posted to the Journal module
Related Topics:
-
See "Managing Allowable File Extensions"


% # Note that this file is not a valid *.html file! # It is intended to be a bottlepy - style template # used for the scripting part of TheOnionBox! # from tob_template_tools import * import psutil cpu_count = psutil.cpu_count() # host = get('host') transport = get('transport_status') %> {{!header_row('Tor', 'Transportation Status', 'transport')}}


{% extends "class/base.html" %} {% block title %} Register {% endblock %} {% block body %}
There's something wrong with what you entered!
Hey, you can't access that page.
Already have account? Login


The documenter middleware in the OwinFramework support the following configuration options:
| Property | Default | Current | Description |
|---|---|---|---|
| Path | {path.default} | {path} |
Configures the relative path within your application where the documenter will be available. For example if your web site is hosted at http://mydomain.com/ and you set this path property to /owin/endpoints then the full url of the visualizer will be http://mydomain.com/owin/endpoints |
| Enabled | {enabled.default} | {enabled} |
The Enabled property allows you to turn off the documenter. You might want to disable the Owin documenter in a production web site to prevent public users from seeing internal details of your application implementation. You could also limit the availability of the documenter by placing middleware in front of it that restricts access to only certain people instead of disabling it. |
| RequiredPermission | {requiredPermission.default} | {requiredPermission} |
The RequiredPermission property allows you to restrict access to the documenter. For this to work you must have some Authorization middleware configured in your Owin pipeline. The name of the permission that you specify here is any permission recognized by the Authorization middleware that you configured. |
This middleware is configured the same way as all other middleware in the Owin Framework; you need to construct a class that implements IConfiguration then add a fluid .ConfigureWith() when you register this middleware with the Owin Framework builder. Please read Owin Framework documentation on configuration for full details with examples.


Get all available regions for the Amazon Cognito Sync service.
| Return type: | list |
|---|---|
| Returns: | A list of boto.regioninfo.RegionInfo |
Amazon Cognito Sync Amazon Cognito Sync provides an AWS service and client library that enable cross-device syncing of application-related user data. High-level client libraries are available for both iOS and Android. You can use these libraries to persist data locally so that it’s available even if the device is offline. Developer credentials don’t need to be stored on the mobile device to access the service. You can use Amazon Cognito to obtain a normalized user ID and credentials. User data is persisted in a dataset that can store up to 1 MB of key-value pairs, and you can have up to 20 datasets per user identity.
alias of JSONResponseError
Deletes the specific dataset. The dataset will be deleted permanently, and the action can’t be undone. Datasets that this dataset was merged with will no longer report the merge. Any consequent operation on this dataset will result in a ResourceNotFoundException.
| Parameters: |
|
|---|
Gets metadata about a dataset by identity and dataset name.
| Parameters: |
|
|---|
Gets usage details (for example, data storage) about a particular identity pool.
| Parameters: | identity_pool_id (string) – A name-spaced GUID (for example, us- east-1:23EC4050-6AEA-7089-A2DD-08002EXAMPLE) created by Amazon Cognito. GUID generation is unique within a region. |
|---|
Gets usage information for an identity, including number of datasets and data usage.
| Parameters: |
|
|---|
Lists datasets for an identity.
| Parameters: |
|
|---|
Gets a list of identity pools registered with Cognito.
| Parameters: |
|
|---|
Gets paginated records, optionally changed after a particular sync count for a dataset and identity.
| Parameters: |
|
|---|
Posts updates to records and add and delete records for a dataset and user.
| Parameters: |
|
|---|


{% extends "global/Page.html" %} {% load staticfiles otree %} {% block title %} End of Game Results {% endblock %} {% block content %}
Your experimental earnings were: {{ payoff }} points
If this game is randomly chosen for payment, your payment from this part of the experiment would be ${{ possible_payoff }}.
{% comment %}Your show up payment was: ${{ Constants.endowment }}.00
Your total earnings are: ${{ total_payoff }}
{% endcomment %}


Papers
My Story, My Mantra
...Instead of asking “Could he,” I began asking “Now or ten minutes later?” I learned to sell myself. More importantly, I was subliminally bringing kids in my neighborhood together...
Bits and Bytes: Fight or Flight
The words hi and bye have been replaced by Wi and Fi...Schools can dramatically revolutionize their teaching methods by nurturing students in a global-industry-driven environment which implements...
2008 Recession
People lost their jobs. Homes were unaffordable. Banks were seen as bullies. Government drowned in debt. Stock market crashed. This was the Great Recession of 2008...The Great Recession was the result of overvaluing property known as the housing bubble...
Dear Content Creator,
April 10, 2017. Drenched in blood, mentally torn and dignity thrown, Dr. David Dao is aggressively dragged...Many variations of multimedia have erupted since the dot com boom, each new style superior to its predecessor...


Introduction
Important efforts are developing ways to design and build landmark longitudinal data-cohorts for personalized/precision medicine research:
- Diseases/Cancers, to improve our ability to understand better, prevent and treat disease based on individual differences in lifestyle, environment and genetics.
- Health/Wellness, to increase an individual’s chances of remaining healthy throughout life.
These longitudinal data-cohorts will be formed by engaging and organizing a number of participants from a single survival population into data sub-cohorts with a scientific goal to shape efficient predictive models in order to develop a well-defined references "healthy" and "not-healthy" or to find two sub-groups, one with better and the other with worse survival prognosis, for instance.
The characterization of these sub-groups will be facilitated by using a number of tests based on features associated to clinical, molecular, imaging, sensor, self-reported, behavioral, psychological, environmental and genetic/genomics and so on.
A score from a regression of these potential factors(biomarkers) or some other model to characterize the sub-groups can also be used as one unified biomarker, let's called diagnostic/prognostic test.
When well-integrated, the preprocessed data related to these tests is expected to provide an estimation of the difference in the survival of two prognostic subgroups in the single survival population at any given time.
-
This difference in the survival of two prognostic subgroups in the single survival population is the most appropriate in a clinical settings. Therefore, it can be more useful for determining the optimal cut-point of the continuous diagnostic/prognostic test that best discerns between individuals with disease or not.
For simplicity, we call the two prognostic subgroups as positive and negative groups.
Difference in the Survival and the Specificity-Sensitivity-Prevalence Impacts
Mathematically and statistically, the difference in the survival depends directly on how well the two groups are separated by the diagnostic/prognostic test. The two measures that are commonly used to evaluate the performance of screening tests are the sensitivity and specificity of the test. The sensitivity of the test reflects the probability that the screening test will be positive among those who are in positive group. In contrast, the specificity of the test reflects the probability that the screening test will be negative among those who, in fact, are in negative group.
The standard definitions of sensitivity and specificity consider disease status and marker value for sample as time-independent (firmly fixed). Interestingly enough, both the disease status and marker value may change over time, samples considered as disease-free earlier may develop the disease later due to longer study follow-up, and also their marker value may change from baseline during follow-up.
We comprehensively review the definitions of sensitivity and specificity for prognostic modeling and it is in time-dependent medical status.
A potential third parameter, that may be explicitly/directly involved under specific cases related to the magnitude of the sensitivity and specificity, is the rates of the negative and positive patients in the single survival population. This third parameter is called “Prevalence” and numerically defined as the proportion of positive/negative samples in the overall single survival population. In longitudinal study, the survival rates of the single survival population at a given time is function of the prevalence.
Note that the sensitivity and specificity values are not necessary related to the prevalence rates, specially if the sensitivity and specificity values are computed/estimated from an ad hoc cohort study (assuming not inherently biased**). These estimated sensitivity and specificity values are used to estimate the actual difference in the survival of two prognostic subgroups in the single survival population taking into consideration the prevalence of the disease in this single survival population. Then only when the prevalence is defined perfectly, an estimation of the actual difference in the survival of two prognostic subgroups can be calculated or evaluated. For instance to define the positive predictive value for a genetic variant, one needs to know the actual prevalence of this genetic variant in the targeted population.
**The estimated sensitivity and specificity values from an inherently biased cohort study will just provide a biased evaluation to the actual difference in the survival.
Our research questions:
- What are the the magnitude of the sensitivity and specificity values that make the difference in the survival rates of the two prognostic subgroups not explicitly depending on the prevalence(survival rates of single survival population)?
- Highlight specific contour levels of the difference in the survival, i.e. its intrinsic formulation to the variables( Specificity & Sensitivity ) and parameter(Prevalence).
Mathematical/Statistical Models
The Mathematical/Statistical models in this interesting work
are used to describe the difference in the survival of two prognostic subgroups at any given time in terms of equations involving variables( Specificity & Sensitivity ) and parameter(Prevalence) representing the main aspects of the difference in the survival.
We comprehensively review this interesting work in the companion of this essay time-dependent medical status.
Importantly enough, in this essay we will address the concern of the Author about how the prevalence affects the difference in the survival and to what extent?
The analytical form of the difference in the survival(DiS) is given by:
DiS = A / (B*C) ... (*)
where
A = prevalence*(1-prevalence)*(specificity+sensitivity-1)
B = sensitivity*prevalence+(1-specificity)*(1-prevalence)
C = (1-sensitivity)*prevalence+specificity*(1-prevalence)
This quantity (*) was also derived and called "Predictive Summary Index" in this seminal work,
New patient-oriented summary measure of net total gain in certainty for dichotomous diagnostic tests. Hence, this comprehensive measure was consistently formulated using algebraic equations related to the diagnostic approach or to the survival modeling.
Its formulation shows that the prevalence is to play a role in the bias of many outcome measures
for test performance. For highly skewed prevalence rates, adequate sample sizes in the
true positive and negative groups are needed for reliable estimates of the sensitivity and specificity values.
It is remarkable that when the magnitude of the sensitivity and specificity values are higher to one,
the difference in the survival can be well-approximated as:
(specificity+sensitivity-1)/(specificity*sensitivity)
(Verily well-approximated when the prevalence is not very low/high, see Section "Informatics Solution".)
Given a test high in specificity and high in sensitivity helps to
achieve a higher or adequate difference in the survival not explicitly depending on the prevalence.
The maximum of the function DiS is equal to one which is also attainable when the magnitude of the sensitivity and specificity values are close to one.
Informatics Solution
A numerical simulation is conducted to study the numerical behavior of the function DiS in (*), as in most nonlinear formulations to assess min/max proprieties, using a number of sampled values representing all possible outcomes related to the variables( Specificity & Sensitivity ) and parameter(Prevalence).
This computer simulation is used to explore and gain new insights into the impact of the variables( Specificity & Sensitivity ) and parameter(Prevalence) and to estimate and highlight specific contour levels of the function DiS as result of its nonlinear formulation to the variables( Specificity & Sensitivity ) and parameter(Prevalence). For visualization purpose, the DiS negative values are replaced by zero.
Discussion & Conclusion
As long as the prevalence is not very low/high and the used test to separate the two groups from a single survival population has both higher specificity and sensitivity values, an adequate difference in the survival of these two prognostic subgroups is attainable and not explicitly depending on the prevalence. In this case, comparing survival curves between two prognostic subgroups is not misleading as the misclassification is minimal.
As for the scalability of the difference in the survival where the rates of the specificity and sensitivity values deteriorate, the magnitude of the difference in the survival surely deteriorates as well and specially when the prevalence rate becomes low or high.
Using poor tests** in longitudinal data-sub-cohorts from a single survival population, specially when the prevalence rate becomes low or high, affect baldly and in a nonlinear relationships the precision of the study. ** The tests(toys) failed to understand that the biological case of the study is substantially complex. Or the tools used to collect, organize, pre/post processing data contents are just messy to help shaping tests that can discern or to predict.
It is essential to combine this information with research analysis tools, i.e. to improve specificity & sensitivity by developing suitable Quality Control and Quality Assurance for the tools used in the designed diagnostic/prognostic tests.
The personalized/precision medicine to be efficient needs sound approach to clinical trials and Informatics Solution. Our system biology is immensely complex and may be less predictable by just insisting on replicating blindly policies and engineered methods that succeeded in the other fields as computer sciences/internet search and so on!
Future Work
Impact of censoring on the used formulations to estimate the sensitivity and specificity values and by consequent on the difference in the survival, is in difference in the survival in the presence of censoring.
Author scientific profile:
Statistics and Applied Mathematics for Data Analytics, Identify opportunities to apply Mathematical Statistics, Numerical Methods, Machine Learning and Pattern Recognition to investigate and implement solutions to the field of Data Content Analytics. Data prediction via computational methods to predict from massive amounts of data (Big Data Content). These methods included clustering, regression, survival analysis, neural network, classification , ranking, deep discrepancy learning .
opportunity


--- layout: post title: IAnticorruption – A Domain-Driven Design Approach To More Robust Integration date: 2007-06-01 16:31:02.000000000 -06:00 type: post published: true status: publish categories: - Library - Strategic Design tags: [] meta: _edit_last: '3110' _dependencies: s:6:"a:0:{}"; _custom_background: a:5:{s:3:"url";s:0:"";s:16:"background-color";s:0:"";s:17:"background-repeat";s:6:"repeat";s:21:"background-attachment";s:6:"scroll";s:19:"background-position";s:8:"left top";} _intro_text: default _intro_custom_banner: a:1:{s:3:"url";s:0:"";} _bitly_trim: http://dddcommunity.org/?p=458 U_S_C_message: '' author: login: bjkitchin email<EMAIL_ADDRESS>display_name: bjkitchin first_name: Robert last_name: Kitchin, Jr ---
For the last two years, Custom House software development team has been making a major push to apply DDD on its projects at both the tactical and strategic levels. This is the second part of their two-part report.
June 2007
Custom House's new currency exchange system is integrated with a legacy system. After a few years of growth, the two systems were so intricately tangled that even small changes made in the integration layer would have unpredictable side effects. Refactoring on the integration layer was risky and time consuming. The situation called for a revolutionary redesign.
The solution was to introduce an anticorruption layer to isolate the two systems. This layer encapsulated the translation of conceptual objects and actions between the two systems, insulating the domain layer from knowing the existence of the other system. By freeing the domain layer from performing tasks that were only relevant to the other system, the anticorruption layer allowed additional external systems to be integrated without requiring any changes to the domain layer itself. Full implementation of an anticorruption layer reduced overhead of legacy integration from 30% of total development to 10%.
The biggest challenge in implementing the anticorruption layer is to control the complexity of translation work. This was managed in an innovative way: by building an object model reflecting the implicit model of the legacy system. Our experiences show that an external system need not be object-oriented for its model to be adequately abstracted, and this has proven to be the key to a clean and extensible translation.