Upon completion of this unit, you will be able to:
The following topics will be covered in this unit:
Docker is a platform for managing the delivery of distributed applications in lightweight, portable, self sufficient containers
Containers are an abstraction of capabilities built into the Linux kernel
Docker is open source software, developed and maintained by a community
Originally created as part of a PaaS offering, provided by dotCloud Inc.
Project governed by the Docker Governance and Advisory Board (DGAB)
Before 20th century, freight transportation was inefficient and hazardous
The inter-modal shipping container revolutionised freight transportation
The packaged container is guaranteed to run unchanged on any platform that runs the Docker Engine
Significantly reduces the friction between development, integration, staging and production environments
VMs are inherently more secure than containers
VMs are better equipped to run multiple processes
Containers are significantly quicker to spin up than VMs, and occupy a smaller footprint
The choice depends on the use case: horses for courses
Docker has not been designed as a leaner replacement for virtual machines
Docker's aim is to facilitate the execution of microservices
Not a physical constraint, but a matter of ideology
Enhanced business agility through expeditious application deployment
Reduced costs, less reliance on expensive software licences
Increased workload density - better return on existing compute resources
Standardised, reproduceable development environments
Microservices aids delivery of faster, better quality software
Incorporation into continuous integration and continuous delivery workflows
Safe experimentation with software components and versions
Containing processes is not a new phenomenon!
Linux kernel features for containers first appeared after the millennium, and matured very recently
A namespace in Linux is a kernel mechanism for isolating a process or processes from specific system-related resources
MNT namespaces isolate the set of filesystem mount points seen by a group of processes
The MNT namespace was introduced in Linux kernel version 2.4.19 (03-Aug-2002)
CLONE_NEWNS
USER namespaces isolate the user and group ID number space
The USER namespace was introduced in Linux kernel version 2.6.23 (09-Oct-2007), but only properly completed in version 3.8 (18-Feb-2013)
CLONE_NEWUSER
PID namespaces isolate the process ID number space
The PID namespace was introduced in Linux kernel version 2.6.24 (24-Jan-2008)
CLONE_NEWPID
NET namespaces isolate the networking stack
The NET namespace was introduced in Linux kernel version 2.6.24 (24-Jan-2008), but only properly completed in version 2.6.29 (23-Mar-2009)
CLONE_NEWNET
IPC namespaces isolate System V IPC objects and POSIX message queues
The IPC namespace was introduced for System V IPC objects in Linux kernel version 2.6.19 (29-Nov-2006), and for POSIX message queues in version 2.6.30 (09-Jun-2009)
CLONE_NEWIPC
UTS namespaces isolate system identifiers returned by the uname() system call
The UTS namespace was introduced in Linux kernel version 2.6.19 (29-Nov-2006)
CLONE_NEWUTS
Cgroups are a kernel capability for allocating and controlling access to system resources
Resource control is provided by a number of cgroup sub-systems or controllers
Ordered hierarchically, with processes belonging to one cgroup for each sub-system
COW generally follows a simple principle. As long as multiple programs need read only access to a data structure, providing them only pointers which point to the same data structure, instead of copying the whole structure to a new one, is enough.
Docker makes use of union mount or snapshot capabilities in order to realise COW filesystems for containers


Easily create tables from data frames/matrices. Create/manipulate tables row-by-row, column-by-column or cell-by-cell. Use common formatting/styling to output rich tables as 'HTML', 'HTML widgets' or to 'Excel'.
| Version: | 0.1.0 |
| Depends: | R (≥ 3.3.0) |
| Imports: | R6 (≥ 2.2.0), dplyr (≥ 0.5.0), jsonlite (≥ 1.1), htmltools (≥ 0.3.5), htmlwidgets (≥ 0.8) |
| Suggests: | lubridate (≥ 1.5.0), listviewer (≥ 1.4.0), openxlsx (≥ 4.0.17), shiny, knitr, rmarkdown, testthat |
| Published: | 2017-09-30 |
| Author: | Christopher Bailiss [aut, cre] |
| Maintainer: | Christopher Bailiss <cbailiss at gmail.com> |
| BugReports: | https://github.com/cbailiss/basictabler/issues |
| License: | GPL-3 |
| URL: | https://github.com/cbailiss/basictabler |
| NeedsCompilation: | no |
| Materials: | README NEWS |
| CRAN checks: | basictabler results |
| Reference manual: | basictabler.pdf |
| Vignettes: |
01. Introduction 01. Introduction 04. Outputs 06. Styling 07. Finding and Formatting 11. Shiny 12. Excel Export |
| Package source: | basictabler_0.1.0.tar.gz |
| Windows binaries: | r-devel: basictabler_0.1.0.zip, r-release: basictabler_0.1.0.zip, r-oldrel: basictabler_0.1.0.zip |
| OS X binaries: | r-release: basictabler_0.1.0.tgz, r-oldrel: basictabler_0.1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=basictabler to link to this page.


Building my own site was one of the most fun yet frustrating challenges of phase 0 for Dev Bootcamp. In week 2 when I first started the site, I was baffled by CSS and could not build a very elegant site--I was happy just to be able to upload my HTML pages to GitHub. Now that I've been updating my site little by little over the past few months, I've become slightly more adept at HTML and CSS. Unfortunately the damage has already been done.
My life would have been a lot easier if I had just started from scratch when revisiting my site this week. The HTML, CSS, and design all needed a major overhaul, and editing fairly ugly code was a headache. There are still plently of issues with my site. There are a few solid starting points as far as laying out divs and separating elements of a site properly from the beginning, but I didn't have the knowhow or wherewithall to implement them. Additionally when I first started, I didn't understand positioning and display properties very well, so I used them liberally as a quick fix. Looking back this was an obvious mistake; it has made implementing an appealing format very difficult. My header and footer are in relation to elements they shouldn't be. When I resize the page, the site doesn't display as nicely as I'd like.
All the above issues are part of the reason why I'm very excited to learn more about frameworks. After I become familiar with Jekyll/Bootstrap, I'll try to remake my site. I may even try to try a single-page implementation. In the future I'd like to add a twitter feed underneath my picture on the side bar. I think my site is pretty easy to follow, but it's still missing something. The design is so raw, and I've been looking at it too long today to put my finger on the exact issue. All I can say is that it doesn't look very modern. I don't think I'll have complete peace of mind until I rework the entire HTML and CSS layout for my entire site.


Yang jokes first thing he'd say to Putin as president is 'Sorry I beat your guy'
by Max GreenwoodAndrew Yang joked on Wednesday that if he's elected president in 2020, his first words to Russian President Vladimir Putin would offer condolences.
"Sorry I beat your guy," Yang said during the fifth Democratic debate when asked what he would say in his first call with Putin.
The remark was a reference to President Trump, who has repeatedly heaped praise on Putin and whose 2016 presidential victory was at the center of a years-long investigation into whether Russian officials sought to interfere in the U.S. political process.
Yang said that Russia's interference in American democracy would also be a key topic of discussion in a phone call with Putin.
"I would say the days of meddling in our elections are over," Yang, a former tech executive, said.
National security officials have already warned that Moscow is taking steps to meddle in the 2020 presidential race.


Documentation
Allocates a block of the requested size and returns
the heap position of that block. If the free list is full and EXPAND
is true, the system will try to expand the free list; otherwise it
returns nil.
As a second value, ALLOCATE-BLOCK returns the number of octets that
were allocated.
Note: both the requested size and the returned heap position include
the block's header.
Source
(defgeneric allocate-block (heap &key size expand)
(:documentation "Allocates a block of the requested size and returns
the heap position of that block. If the free list is full and EXPAND
is true, the system will try to expand the free list; otherwise it
returns nil.
As a second value, ALLOCATE-BLOCK returns the number of octets that
were allocated.
Note: both the requested size and the returned heap position include
the block's header."))
Source Context


Leonardo da Vinci Tribute Page
Leonardo da Vinci
Renaissance Man
Self-portrait c.1510
Here is a timeline of da Vinci's life:
- 1452 - Born on April 15, in Vinci
- 1467 - He was sent off to art school
- 1472 - Joined the Painter's Guild of Florence
- 1482 - Moved to Milan
- 1490's - Began writing his famous notebooks
- 1495 - Painted "The Last Supper"
- 1500 - Returned to Florence
- 1503 - Painted "The Mona Lisa"
- 1506 - Returned to Milan to work as an architect
- 1519 - Leonardo died in France
Check out Leonardo's Wikipedia Page for more information!


Error messages appear mainly for three reasons:
Tip: Google Earth Enterprise Fusion sometimes writes messages to the terminal window from which you launched the GUI. So if an error message pops up in the GUI, but you want more information, check the terminal window for more information.
Some actions you can take to troubleshoot any type of error message:
The Asset Log displays information about that part of the process.
getop
This command allows you to see what Google Earth Enterprise Fusion is currently working on and if gesystem
and gehttpd
are currently running. (See getop in the Command Line Reference chapter, as well as the Administration Guide for more information about these commands.)
/opt/google/share/support/geecheck.pl
The remainder of this appendix provides additional information about the most common error messages you might see in Google Earth Enterprise Fusion, including:
When you try to publish a database on a server that requires authentication.
You entered an invalid user name or password three times.
Check with your system administrator to be sure you have permission to publish a database and have a valid user name and password. Then try entering the user name and password.
Note: Be sure that CapsLock is not on.
In the vector Asset Log.
You might not have full read-write-execute permissions set properly. This includes the folders all the way back to the root.
Enter the following command at the command line:
sudo chmod -R a+r /gevol
This command corrects the access permission on all Google Earth Enterprise Fusion-related files. (This command assumes that you have specified /gevol
as your asset root. If not, substitute the name of your asset root for /gevol
.)
In the vector Asset Log.
There is more than one source file in the resource, and their attributes are not exactly identical. Either the labels are not the same, or one data file has an attribute that the other is missing.
Make the attribute labels match or, if one data set is lacking an attribute, give it an empty column with the same attribute label.
During the transition from version 3.x to future versions.
You tried to use an older or newer version of the Google Earth Enterprise Fusion GUI (or shell command) to connect to the system manager.
Properly upgrade Google Earth Enterprise Fusion to the latest version you own.
During the initial transition from tools that do not check for matching versions to the versions that do check (for example, from 2.4.x to 3.x).
You tried to use an old version of the Google Earth Enterprise Fusion GUI (or shell command) to connect to a new version of the system manager.
Properly upgrade Google Earth Enterprise Fusion to the latest version you own.
In the index of the project Asset Log.
One of your layers is set to not display any data.
This error usually occurs when you make a mistake in the filters. For example, using a comma in a filter value (such as 2,000 instead of 2000), selecting Match all of the following when you mean to select Match any of the following, selecting equals instead of does not equal, and so on.
In an error message dialog or on the command line in the terminal window from which you launched Google Earth Enterprise Fusion.
Google Earth Enterprise Fusion tried to read from or write to disk, and permission was denied, indicating that read/write permissions are not set correctly.
Enter the following command:
chmod a+r path
Where path is the full path to the folder you are trying to access.
Background daemons that run as the gefusionuser:gegroup
user and group build assets in Google Earth Enterprise Fusion. You must be particularly careful with source files that you create or copy to set permissions that allow the Google Earth Enterprise Fusion daemons to access them. This frequently means read access for all.
Even if a file has the correct permissions set, the Google Earth Enterprise Fusion daemons cannot access it unless all of the parent directories have both read and execute permissions set for gefusionuser:gegroup
.
In the project Asset Log and the terminal window.
The application aborts due to a software bug (similar to a segmentation fault).
Contact Google Earth Enterprise Fusion technical support.
In the project Asset Log and the terminal window.
This is the same as Segmentation fault.
This is the same as Segmentation fault.
When you try to publish a database.
The network connection to the server is down, or permissions are set incorrectly where the publisher is attempting to write data.
Check your network connections and ensure that the targeted server is running and accessible. Check the access permissions in the publishing root directory. Check the Google Earth Enterprise Server logs.
Run the debug script to scan the system and assist in identifying problems:
/opt/google/share/support/geecheck.pl
Can occur anywhere at anytime.
This error message usually indicates a bug in the software.
Please report it to Google Earth Enterprise Fusion technical support.
(where <IP_ADDRESS> is your IP address)
In the vector Asset Log and when starting Google Earth Enterprise Fusion in shell.
You may not have the system daemons running.
On the command line, enter:
sudo /etc/init.d/gesystem stop
sudo /etc/init.d/gesystem start
When you try to publish a database.
The specified server is not running, or a service that it requires is not running.

Multiple locations. (See above.)
Your hard disk might be full, or a network drive might be disconnected.
/etc/init.d/gesystem stop
/etc/init.d/gehttpd stop
sleep 5
killall -9 gesystemmanager
killall -9 geresourceprovider
ps aux | grep ge
/etc/init.d/gesystem start
/etc/init.d/gehttpd start
During the initial transition from tools that do not check for matching versions to the versions that do check (for example, from 2.4.x to 3.x).
You tried to use a later version of the Google Earth Enterprise Fusion GUI (or a shell command) with a previous version of the system manager.
Properly upgrade Google Earth Enterprise Fusion and the Google Earth Enterprise Server to the latest version you own.
When you try to publish a database.
The network connection to the server is down, or permissions are set incorrectly where the publisher is attempting to write data.
Check your network connections and ensure that the targeted server is running and accessible. Check the access permissions in the publishing root directory. Check the Google Earth Enterprise Server logs.
The first time each user runs the Google Earth Enterprise Fusion GUI, a series of error messages similar to the following appear in the terminal window where you launched Google Earth Enterprise Fusion:
Fusion Notice: Saving /gevol/assets/.config/misc.xml with defaults
Conflict in /opt/kde3/lib/kde3/plugins/styles/keramik.so:
Plugin uses incompatible Qt library!
expected build key "i686 Linux g++-4 full-config",
got "i686 Linux g++-3.* ful l-config".
Conflict in /opt/kde3/lib/kde3/plugins/styles/kthemestyle.so:
Plugin uses incompatible Qt library!
expected build key "i686 Linux g++-4 full-config",
got "i686 Linux g++-3.* ful l-config".
Conflict in /opt/kde3/lib/kde3/plugins/styles/highcolor.so:
Plugin uses incompatible Qt library!
expected build key "i686 Linux g++-4 full-config",
got "i686 Linux g++-3.* ful l-config".
Conflict in /opt/kde3/lib/kde3/plugins/styles/light.so:
Plugin uses incompatible Qt library!
expected build key "i686 Linux g++-4 full-config",
got "i686 Linux g++-3.* ful l-config".
These error messages are caused by an incompatibility between some of the plug-ins (GUI widgets) distributed with the operating system and the Qt library that we compile are incompatible. This is not a problem, because we do not use the incompatible plug-ins. These error messages appear the first time the user launches the Google Earth Enterprise Fusion GUI only.
No action is necessary.
For the most up-to-date information about Google Earth Enterprise, please email the Google Enterprise Support Team at enterprise-support@google.com.


Quicklinks
If you know what this is all about and you only need to go to specific templates:
Overview
In addition to cross build and debugging support, the Eclipse Embedded CDT plug-ins also provide several C/C++ project templates, that generate ready to run projects.
These projects obviously are not full fledged applications, but provide a good starting point for writing such applications.
One of the main requirements is to build correctly, even if functionality is only sketchy.
Install
The template plug-ins are installed using the same procedure as the other plug-ins:
- in the Eclipse menu, go to Help → Install New Software
- select Work with: Eclipse Embedded CDT
- extend the Embedded C/C++ Cross Development Tools
- be sure the desired Embedded C/C++ … Project Template are selected
C vs C++
Most of the Eclipse Embedded CDT templates are available for both C and
C++ projects. The first difference between the two is the extension of
the main source file: it is main.c
for C projects and main.cpp
for
C++ projects. The content is usually the same, but more elaborate versions
are planned to better exemplify the use of C++.
CMSIS
After defining a minimum common hardware implementation in the Cortex-M core, to be implemented by all vendors, Arm also defined CMSIS (pronounced sim-sys) as a common software interface, to be used with all Cortex-M implementations. CMSIS stands for Cortex Microcontroller Software Interface Standard and consists of several components (CORE, DSP, RTOS, SVD).
The Eclipse Embedded CDT plug-ins uses the CMSIS-CORE code in all templates, as jointly provided by Arm and each vendor.
Blinky vs Empty
Based on a long tradition among the embedded application developers, the first challenge when encountering a new board is to make it blink a LED. It doesn’t seem much, but in fact there are many details that must fit together for this to work:
- the startup code must be functional
- the manufacturer CMSIS initialisations must set the desired clock
- the GPIO definitions/drivers must be available
- the memory map and the linker scripts must match the actual hardware
- possibly the newlib
printf()
must be directed to an available device for viewing the trace messages
The Blinky template does exactly this, takes care of all these details.
The observed functionality is relatively simple, the board blinks a LED with
1Hz. To exercise the interrupts, the time base is obtained with the SysTick
configured at 1000Hz, with the delay()
function counting ticks.
Once all details are understood, a real life application does not really need
the code to blink the LED, but rather start with an empty slate. This is
the purpose of the Empty template, that provides the entire environment
of the Blinky template, but without any code in main()
.
Project structure
Most generated projects share a common folders structure, similar to the following:
Application code
The application code is located in the top level src
and include
folders.
Add more files as required by your application.
Linker scripts
The linker scripts are grouped in a ldscripts
folder. For convenience,
the definitions were split in separate files to define the memory map and
the content of the sections, but any other structure is acceptable, only
update the link configuration.
Local libraries
Various libraries are grouped in the system
folder. According to Arm
specifications, the Cortex Microcontroller Software Interface Standard
(CMSIS) is used, and all related definitions are grouped in the CMSIS folder.
Available templates
Generic templates
- Cortex-M template
ST Micro templates
- STM32F0xx template
- STM32F1xx template
- STM32F2xx template
- STM32F3xx template
- STM32F4xx template
- STM32F7xx template
Freescale templates
- Kinetis KLxx templates
- Processor Expert template
Adding new templates
Considering the large number of existing Cortex-M implementations, it is not realistic to expect templates for all of them.
If you use a microcontroller that has no template yet, and want to contribute to this project, the first step is to create a project that mimics the Blinky variant of an existing template. This means you need to have the CMSIS specific files publicly available (yes, this seems strange, but some manufacturers do not provide these files) and possibly the standard peripheral library.
If you have such a project, you can register a new feature request and attach your project to the request, for us to review and possibly use as a base for a new template.
Comments on the content of this page that might be useful for other readers are welcomed here. For question and general support, please use the project forums.


Aux/IAA gene proteins genes auxin family Plant plant Aux/IAAs domain motif pairs protein NLS domains ARF analysis {border-style bipartite plants response tandem duplication px;} #ffffff;} Figure contained segmental sequences Biol. IAA, conservative species Sci. Wang expression phylogenetic thaliana Arabidopsis Mol. lower number canonical evolutionary expansion motifs paralogous plants. signaling ARFs Genome-wide T.J. different duplications events land patens patterns sequence transcriptional type Guilfoyle SV-like acid evolution substitution Hagen Ka/Ks Physiol. amino development factor families functional generally max model proteins. px; roles truncated {font-family (Part ./s--- Clade However, Liu Molecular degenerated duplicated font-size functions grouped growth lacked moellendorffii multiple new order origin repression sister tree using (K) Analysis Cell NLSs Table activity changes correlated double; genome identified indicating involved molecular mutation nuclear plants, region rice second segmentally thaliana, types used value (including Dharmasiri Domain Duplication Interestingly, OsIAA RxxRK Wentao Zea Zhang addition, arginine assumed auxin-responsive auxin/indole--acetic basic basis border-color border-width compared conserved diversity dominant evolution, evolution. function higher identify interaction lysine major mays members monocots, mutant nucleus pair perception purifying putative redundancy regulate respectively. responsible results root sativa selection selection. solid; supported tandemly total transcription typical {font-style {font-weight (.%) ./fpls.. ./j.-X...x ./journal.pone. AXR Acad. AtIAA Aux/IAAs. Estelle Evolution Front. Gene Genet. Glycine Glyma.G. IAA IAA), IAA- II, III III, Identification J.W. Moreover, NLS, Natl. Proc. Reed S). Science Solanum Then, USA abies article bold built cause causes contribute copy correlated, courier; course did divided duplication, em; emergence essential family, genes, hormone including indicated interactions kinds lacking large lateral localization maize mutations observed online: pathway perform performed physical presence profiling pt;} rate role shows signals single species. specifically substituted undergone understanding


UVIS Pipleline¶
As of version 3.3, the calwf3 pipeline processes all UVIS data twice, once with the CTE correction applied as the first step, and a second time without the CTE correction. A short description of the calibration steps, in the order they are performed:
- Calculate and remove and CTE found in the image (PCTECORR)
- Calculate a noise model for each pixel and record in the error array (ERR) of the image (NOISCORR)
- Initialize the data quality(DQ) array of the image (DQICORR)
- Correct fo A-toD conversion errors where necessary, currently skipped (ATODCORR)
- Subtract bias level determined from overscan regions (BLEVCORR)
- Subtract the bias image (BIASCORR)
- Detect and record SINK pixels in the DQ mask (performed if DQICORR is set to PERFORM)
- Perform unit conversion
- Subtract the post-flash image if applicable (FLSHCORR)
- Scale and subtract the dark image (DARKCORR)
- Perform flatfielding (FLATCORR)
- Perform shutter-shading correction where necessary, currently skipped (SHADCORR)
- Populate photometric header keywords (PHOTCORR)
- Correct chips to be on the same zeropoint (FLUXCORR)
- Calculate image statistics for the header
Correction For Charge Transfer Efficiency (PCTECORR)¶
The charge transfer (CTE) of the UVIS detector has been declining over time as on-orbit radiation damage creates charge traps in the CCDs. Faint sources in particular can suffer large flux losses or even be lost entirely if observtions are not planned and analyzed carefully. The CTE depends on the morphology of the source, the distribution of electrons in the field of view, and the population of charge traps in the detector column between the source and the transfer register. Further details of the current understanding of the state of the WFC3/UVIS charge transfer efficieny (CTE) are presented in Section 5 of the data handbook as well as on the WFC3 CTE webpage . The PCTECORR step aims to mitigate the flux loss incurred from CTE.
More information on this part of the pipeline can be found in the wf3cte documentation.
Error Array Initialization¶
The image error array is initialized. The function examines the RR extension of the input data to determine the state of the array. The input _raw image contains an empty ERR array. If the ERR array has already been expanded and contains values other than zero, then this function does nothing. Otherwise it will intialize the ERR array by assigning pixel values based on a simple noise model. The noise model uses the science (SCI) array and for each pixel calculates the error value \(\sigma\) in units of DN:
The CCDTAB reference file contains the bias, gain and readnoise values used for each CCD aplifier quadrant used in this calculation. The table contains one row for each configuration that can be used during readouse, which is uniquely identified by the list of amplifiers (replicated in the CCDAMP header keyword), the particular chip being read out (CCDCHIP), the commanded gain (CCDGAIN), the commanded bias offset level (CCDOFST) and the pixel bin size (BINAXIS). These commanded values are used to find the table row that matches the characteristics of the image that is being processed and reads each amplifiers characteristics, including readnoise (READNSE), A-to-D gain (ATODGN) and the mean bias level (CCDBIAS).
Data Quality Array Initialization (DQICORR)¶
This step initializas the data quality array by reading a table of known bad pixels for the detector, as stored in the Bad Pixel reference table BPIXTAB. The types of bad pixels that can be flagged are:
| NAME | VALUE | DESCRIPTION |
|---|---|---|
| GOODPIXEL | 0 | OK |
| SOFTERR | 1 | Reed-Solomon decoding error |
| DATALOST | 2 | data replaced by fill value |
| DETECTORPROB | 4 | bad detector pixel or beyond aperture |
| DATAMASKED | 8 | masked by occulting bar |
| HOTPIX | 16 | hot pixel |
| CTETAIL | 32 | UVIS CTE tail |
| WARMPIX | 64 | warm pixel |
| BADBIAS | 128 | bad bias value |
| SATPIXEL | 256 | full-well or a-to-d saturated pixel |
| BADFLAT | 512 | bad flatfield value |
| TRAP | 1024 | UVIS charge trap, SINK pixel |
| ATODSAT | 2048 | a-to-d saturated pixel |
| ne TBD | 4096 | reserved for Multidrizzle CR rej |
| DATAREJECT | 8192 | rejected during image combination UVIS, IR CR rejection |
| CROSSTALK | 16384 | ghost or crosstalk |
| RESERVED2 | 32768 | can’t use |
Sink Pixel Detection and Marking¶
Sink pixels are a type of image defect. These pixels contain a number of charge traps and under-report the number of electrons that were generated in them during an exposure. These pixels can have an impact on nearby upstread or downstream pixels, though they often only impact one or two pixels when the background is high, they can impact up to 10 pixels if the background is low.
Flagging of SINK pixels in the DQ extension of calibrated images is controlled with the DQICORR header keyword, happens after the bias correction has been performed, and is done in the amp-rotated CDAB full image format used and described in the CTE correction. When set to perform, the sink pixels are located and flagged with help from the SNKCFILE reference image. Given the reference image, the procedure for flagging the sink pixel in science data involves:
- Extract the MJD of the science exposure
- Go through the reference image pixel by pixel looking for those pixels with values greater than 999, which indicates that the current pixel is a sink pixel. The value of this pixel in the reference file corresponds to the date at which this pixel exibited the sink behavior.
- If the turn on date of the sink pixel is after the exposure date of the science image, then we ignore the sink pixel in this exposure and move on to the next pixel
- If the turn on date of the sink pixel is before the exposure date of the science image, then this science pixel was compromised at the time of the exposure.The corresponding DQ extension pixel for this science pixel is flagged with the “charge trap” flag of 1024.
- If the pixel “below” the sink pixel in the long format image has a value of -1 in the reference image, then it is also flagged with the “charge trap” value in the DQ extension. We then proceed vertically “up” from the sink pixel and compare each pixel in the reference file to the value of the sink pixel in the science exposure at hand. If the value of the sink pixel in the exposure is below the value of the upstream pixel in the reference image, we flag that pixel with the “charge trap” value in the DQ extension. We continue to flag pixels until the value of the pixel in the reference image is zero or until the value of the sink pixel in the exposure is greater than the value of the upstream pixel in the reference image.
WFC3 ISR 2014-19 has a detailed analysis on detection of the sink pixels, while the strategy for flagging them is discussed in WFC3 ISR 2014-22 .
Sink pixels are currently only flagged in full frame science images, a future release of calwf3 will also perform flagging in subarray images. The pipeline currently does no further analysis or correction on pixels which have been flagged as affected by sink pixels
Unit Conversion to Electrons¶
The UVIS image is multiplied by gain right after BIASCORR, converting it to ELECTRONS. This step is no longer embedded within FLATCORR.
Bias Correction (BIASCORR)¶
This step subtracts the two dimensional bias struction from the image using the superbias reference image listed in the header keyword BIASFILE. The dimensions of the image are used to distinguish between full and sub-array images. Because the bias image is already overscan-subtracted, it will have a mean pixel value of less than one. The BIASFILE has the same dimensions as a full-size science image, complete with overscan regions. Only after completion of wf3ccd are the science images trimmed to their final calibrated size. The same reference image is used for full-frame and subarray images, calwf3 will extract the matching region from the full-size bias file and apply it to the subarray image.
Overscan Bias Correction (BLEVCORR)¶
The location of the overscan regions in a raw image varies, depending upon the type of readout that is performed. The overscan regions are used to monitor the instrument as well as provide a measure of the bias level at the time the detector was exposed. The bias level which is calculated for subtraction is done on a line-by-line basis in the image. If the image has no overscan region the BIAS level to be subtracted is obtained from the CCDTAB reference file. Otherwise, the columns to use for the calculation are referenced in the OSCNTAB reference file. A bias drift calculation is made if there are virtual overscan pixels which exist, if neither of the virtual overscan regions are specfied then the physical overscan region is used.
If there are two sections available to use for the line because only 1 amp was used then they are averaged. The parallel overscan region is split into two if there is more than one amp. If the virtual overscan is used, a straight line is fit as a function of the column number. The fit is evaluated for each line and then subtracted from the data. Iterative sigma clipping is used to reject outliers from the array of bias values.
The mean value of all the bias levels which were subtracted is recorded in the SCI extension output header in MEANBLEV.
Dark Current Subtraction (DARKCORR)¶
The reference file listed under the DARKFILE header keyword is used as the reference dark image.
In the UVIS, the dark image is scaled by EXPTIME and FLASHDUR.
The reference file pointed to with DARKFILE is used for the non-CTE corrected data.
The reference file pointed to with DRKCFILE is used for the CTE corrected data
Shutter Shading Correction (SHADCORR)¶
This step corrects the science image for differential exposure time across the detector cased by the amount of time it takes for the shutter to completely open and close, which is a potentially signiciant effect only for images with very short exposure times (less than ~5 seconds). Pixels are corrected based on the exposure time using the relation:
WFC3 tests have shown that the shutter shading effect is insignificant (< 1%), even for the shortest allowed UVIS exposure time of 0.5 seconds (see WFC3 ISR 2007-17). Therefore this step is ALWAYS set to OMIT in calwf3.
Post-Flash Correction (UVIS ONLY) (FLSHCORR)¶
WFC3 has post-flash capability to provide a means of mitigating the effects of Charge Transfer Efficiency (CTE) degredation. When FLSHCORR=PERFORM, this routine subtracts the post-flash reference image, FLSHFILE, from the science image after DARKCORR in the WF32D step. The success of the post-flash operation during the exposure is first verified by checking the keyword FLASHSTA. The FLSHFILE is renormalized to the appropriate post-flash current level (LOW, MED, HIGH) recorded in the FLASHCUR keyword, and the flash duration (FLASHDUR) and is then subtracted from the science image. The mean value of the scaled post-flash image is written to MEANFLSH in the output SCI extension header. Different members of an association can have different values of SHUTRPOS because it varies by exposure, and this is fine for calibration because the references files are populated separately for each exposure.
| KEYWORD | DESCRIPTION |
|---|---|
| FLSHDUR | is the length of time of the flash exposure |
| FLSHCUR | is the current that was used to the lamp as calculated by TRANS, which also calculates FLASHEXP, (ZERO, LOW, MED,HIGH) |
| FLSHFILE | is the flash reference file, which has an illumination pattern for each shutter |
| SHUTRPOS | says which shutter was used |
| FLASHSTA | indicates an interrupted exposure (ABORTED, SUCCESSFUL, NOT PERFORMED) |
| FLASHLVL | post flash level in electrons |
| MEANFLSH | the mean level which calwf3 calculated and then subtracted |
FLATCORR¶
Correct the image for pixel quantum efficiency using the reference image specified by the FLATFILE keyword in the header. Conversion from DN to ELECTRONS no longer depends on FLATCORR=PERFORM, all images are converted appropriately.
This actually consists of correction using up to 3 reference flat images:
- PFLTCORR: apply a pixel-to-pixel flat (ground flats)
- DFLTCORR: apply a delta flat, applies any needed changes to the small-scale PFLTFILE
- LFLTCORR: apply a low order flat, correcting for large scale sensativity variations (on-orbit)
The pipeline is currently only using the P-flats. If two or more reference files are specified, they are read in line-by-line and multiplied together to form a combined flatfield correction image.
Subarray science images use the same reference file as the full-frame images; calwf3 will extract the appropriate region from the reference file and apply it to the subarray input image.
Photometry Keywords (PHOTCORR)¶
The PHOTCORR step is performed using tables of precomputed values instead of calls to SYNPHOT, it uses the reference table specified in the IMPHTTAB header keyword. Each DETECTOR uses a different table.
If you do not wish to use this feature, set the header keyword PHOTCORR to OMIT. However, if you intend to use the FLUXCORR step, then PHOTCORR must be set to PERFORM as well.
- PHOTFNU: the inverse sensitivity in units of :math: Jansky sec electron^{-1}`
- PHOTFLAM: the inverse sensistiy in units of \(ergs\ cm^{-2} A^{-1} electron^{-1}\)
- PHOTPLAM: the bandpass pivot wavelength
- PHOTBW: the bandpass RMS width
- PHTFLAM1: the inverse sensistiy in units of \(ergs cm^{-2} A^{-1} electron^{-1}\)
- PHTFLAM2: the inverse sensistiy in units of \(ergs cm^{-2} A^{-1} electron^{-1}\)
For versions 3.3 and beyond, the value PHOTFNU is calculated specific for each UVIS chip, see the section on FLUXCORR for more information.
The SCI headers for each chip contain the PHOTFNU keyword, which is valid for its respective chip, where PHOTFNU is calculated as:
For UVIS 1: \(photfnu = 3.33564e^{4} * PHTFLAM1 * PHOTPLAM^{2}\)
For UVIS 2: \(photfnu = 3.33564e^{4} * PHTFLAM2 * PHOTPLAM^{2}\)
The IMPHTTAB file format for WFC3 UVIS is as follows:
EXT# FITSNAME FILENAME EXTVE DIMENS BITPI OBJECT
0 z7n21066i_imp z7n21066i_imp.fits 16
1 BINTABLE PHOTFLAM 1 5Fx256R
2 BINTABLE PHOTPLAM 1 5Fx256R
3 BINTABLE PHOTBW 1 5Fx256R
4 BINTABLE PHTFLAM1 1 5Fx256R
5 BINTABLE PHTFLAM2 1 5Fx256R
where each extension contains the photometry keyword information for that specific header keyword. The rows inside the tables are split on observation mode.
Flux normalization for UVIS1 and UVIS2 (FLUXCORR)¶
The FLUXCORR step was added in calwf3 v3.1.2 as a way to scale the UVIS chips so that the flux correction over both chips is uniform. This requires new keywords which specify new PHOTFLAM values to use for each chip as well as a keyword to specify the scaling factor for the chips. New flatfields must be used and will replace the old flatfields in CDBS but the change will not be noticable to users. Users should be aware that flatfield images used in conjunction with v3.2.1 of the software should not be used with older versions as the data, and vice versa will be scaled incorrectly.
The new keywords include:
- PHTFLAM1: The FLAM for UVIS 1
- PHTFLAM2: The FLAM for UVIS 2
- PHTRATIO: The ratio: PHTFLAM2 / PHTFLAM1, which is calculated by calwf3 and is multiplied with UVIS2 (SCI,1 in the data file)
In order for FLUXCORR to work properly the value of PHOTCORR must also be set to perform since this populates the header of the data with the keywords FLUXCORR requires to compute the PHTRATIO.
This step is performed by default in the pipeline and the PHOTFLAM keyword will be valid for both chips after the correction has been applied.


These sandwiches are the best I've ever tasted, for sure. I now eat them every day - breakfast, lunch and dinner.
Mr Smith, Professional sandwich tasterMy team are always far more productive after we order from Sam's. 40% more productive, in fact.
Miss McAdam, CEO Workplace AnalyticsWe believe that healthy workers are more productive workers.
Providing your team with a healthy lunch each day improves both motivation and morale.
We deliver healthy sandwiches, made with the best ingredients, to your workplace every day.
DISCLAIMER:
If you need medical advice out of hours, ring 111
If you have a life-threatening medical emergency, ring 999


Ivan du Toit is an eager learner willing to do any task that delivers the most value to the business, large or small. He has a record of keeping track of complex domains while leading high performance teams at companies like Amazon Web Services
I am the team lead for the team that builds the EC2 (https://console.aws.amazon.com/ec2/home) management console. My focus is on increasing operational excellence and increasing our delivery velocity. This includes training new team members and driving the development of a DSL and framework to allow us to delivery more value to out customers, faster.
I worked in the User Experience team to build the EC2 (https://console.aws.amazon.com/ec2/home) and VPC (console.aws.amazon.com/vpc/home) management consoles. To increase my exposure I am also involved in EC2 API design. Giving back is also important to me by helping newbies in operational excellence 101 training along with mentoring and helping interns
I worked in the User Experience team to build a UI testing framework based on CasperJS and PhantomJS.
I helped students in the COS 151 and COS 110 modules to understand programming practice and complete the course work successfully.
Web applications development and testing including creating a custom content management system. Lead development on the CMS during the last year.
Recieved an invitation to join the socieity due to academic performance during the course of my studies.
Recieved South African colours for U/20 Fencing
Won the South African U/20 nationals
Lead a team to participate in the FIRST Robotics League as part of a community outreach and enrichment program. Won the "Best Programmer" award at the FIRST Robitics League national finals in 2006.


Structures
The following structures are available globally.
-
Erases the protocol
See moreMiddleware
. Please check its documentation for more information.Declaration
Swift
public struct AnyMiddleware<InputActionType, OutputActionType, StateType> : MiddlewareProtocol
-
ActionHandler
defines a protocol for entities able to handle actions - defined by the associated typeActionType
andAnyActionHandler
erases this protocol to a generic struct type.The only protocol requirement is a function that allows other entities to dispatch actions, so Views (or Presenters, ViewModels) in your UI layer, or even Middlewares can create actions of a certain type and send to your store, that is generalized by this protocol.
See moreDeclaration
Swift
public struct AnyActionHandler<ActionType> : ActionHandler
-
Representation of the entity responsible for creating and dispatching the action, including information useful for logging, debugging, analytics or monitoring. The action source will be implicitly created when
ActionHandler.dispatch
is called from a middleware, view or presenter, and it will contain the file, function and line from where the dispatch function was called. Additionally you can append extra information useful for debugging, as an optional String attached to the ActionSource.The Action Source will arrive at every middleware’s
See morehandle
function, and you have the opportunity to use this information when performing side- effects, such as printing logs.Declaration
Swift
public struct ActionSource : Codable, Hashable
-
Wraps an action and the information about its dispatcher. It can be used when reactive pipelines want to enforce that the result is an action while keeping track about the source of that action. For example, certain RxSwift, Combine or ReactiveSwift pipeline want to send actions to the store and because ActionHandler has a function
See moredispatch(_ action: ActionType, from dispatcher: ActionSource)
, that pipeline should output aDispatchedAction<Action>
to fulfil everything needed by the ActionHandler to feed that action into the store.Declaration
Swift
public struct DispatchedAction<Action>
extension DispatchedAction: Decodable where Action: Decodable
extension DispatchedAction: Encodable where Action: Encodable
extension DispatchedAction: Equatable where Action: Equatable
extension DispatchedAction: Hashable where Action: Hashable
-
AnyStateProvider
erases the protocolStateProvider
, which defines a entities able to offer state publishers (Combine Publisher, RxSwift Observable, ReactiveSwift SignalProducer) of certainStateType
, so everybody can observe the global state changes through this container. Usually aStore
will implement that, but it can also be aStoreProjection
with a state that is derived from the global source-of-truth.The only protocol requirement is to offer a property
See morestatePublisher
that will allow other entities to subscribe to state changes and react to those.Declaration
Swift
public struct AnyStateProvider<StateType> : StateProvider
-
A MiddlewareReader is a way to lazily inject dependencies into a Middleware. For example, you may want to compose multiple middlewares but from a library, and in this library you don’t have the dependencies to inject just yet, because these dependencies are only present in the main target. That way, instead of creating the middlewares (which would require all the dependencies), you can wrap their initializers in a MiddlewareReader. The middleware reader is not a middleware, is a a factory (in OOP terms) from
See more(Dependencies) -> MiddlewareType
(in FP approach). The benefit of wrapping the middleware initializers in a MiddlewareReader is that, for all means, MiddlewareReaders can be composed as Middlewares, can be lifted as Middlewares, but all of this without in fact creating the Middlewares. Your library can then expose a single MiddlewareReader as public, and you keep all its middlewares as internal classes. From the main target you compose this MiddlewareReader with other MiddlewareReaders coming from other libraries and from the main target itself.  Remember that “inject then compose” is the same as “compose then inject”, but while the former needs dependencies upfront, the latter is more flexible for being lazy. For those familiar with Functional Programming, this is similar to Reader Monad, but as SwiftRex recommends dependencies only on Middlewares, this Reader works specifically with Middlewares.Declaration
Swift
public struct MiddlewareReader<Dependencies, MiddlewareType> : MiddlewareReaderProtocol where MiddlewareType : MiddlewareProtocol
extension MiddlewareReader: Semigroup where MiddlewareType: Semigroup
extension MiddlewareReader: Monoid where MiddlewareType: Monoid
-
Wraps a closure that will be called after the Reducer pipeline has changed the state with the current action. With this structure, a middleware can schedule some callback to be executed with the new state, and evidently access this state to check what’s different. This can be very useful for Middlewares that perform logging, monitoring or telemetry, so you can check the state before and after reducers’ execution, or how much time it took for the whole chain to be called (in case this middleware is the first in the chain, of course).
See moreAfterReducer
is a monoid, that means it can be combined with anotherAfterReducer
to form a new one (that executes both operations in the reverse order) and an identity instance, that when combined with any otherAfterReducer
changes nothing in the result, acting as a neutral element in composition. The identity of anAfterReducer
is the static instancedoNothing()
, that contains an empty closure for no-op. The combination between twoAfterReducer
instances occur in reverse order so the first middleware will have its “after reducer” closure executed last. This composition can be achieved by using the operator<>
Declaration
Swift
@available(*, deprecated, message: "Use `MiddlewareProtocol` instead of `Middleware`. It doesn't use `AfterReducer`. This struct will be removed on 1.0.") public struct AfterReducer : Monoid
-
A very eager scheduler that will perform tasks in the Main Queue, immediately if possible.
If current queue is MainQueue, it will behave like
See moreImmediateScheduler
(https://developer.apple.com/documentation/combine/immediatescheduler) and perform the task immediately in the current RunLoop. If the queue is different, then it will schedule to the Main Dispatch Queue and perform as soon as its new RunLoop starts (depending on the DispatchQueue.SchedulerOptions provided). UseASAPScheduler.default
in order to use this Scheduler.Declaration
Swift
@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) public struct ASAPScheduler
extension ASAPScheduler: Scheduler
-
Undocumented
See moreDeclaration
Swift
public struct ElementIDAction<ID, Action> where ID : Hashable
extension ElementIDAction: Identifiable
extension ElementIDAction: Decodable where ID: Decodable, Action: Decodable
extension ElementIDAction: Encodable where ID: Encodable, Action: Encodable
extension ElementIDAction: Equatable where Action: Equatable
extension ElementIDAction: Hashable where Action: Hashable
-
Undocumented
See moreDeclaration
Swift
public struct ElementIndexAction<Index, Action> where Index : Comparable
extension ElementIndexAction: Decodable where Index: Decodable, Action: Decodable
extension ElementIndexAction: Encodable where Index: Encodable, Action: Encodable
extension ElementIndexAction: Equatable where Index: Equatable, Action: Equatable
extension ElementIndexAction: Hashable where Index: Hashable, Action: Hashable
-
Abstraction over subscriber/observer types from reactive frameworks. This abstraction uses concept similar to type-erasure or protocol witness pattern, wrapping the behaviour of concrete implementations and delegating to them once the wrapper funcions are called.
See moreDeclaration
Swift
public struct SubscriberType<Element, ErrorType> where ErrorType : Error
-
Abstraction over publisher/observable/signal producer types from reactive frameworks. This abstraction uses concept similar to type-erasure or protocol witness pattern, wrapping the behaviour of concrete implementations and delegating to them once the wrapper funcions are called.
See moreDeclaration
Swift
public struct PublisherType<Element, ErrorType> where ErrorType : Error
-
Abstraction over passthrough subject types (
See morePassthroughSubject
,PublishSubject
,Signal
) from reactive frameworks. This abstraction uses concept similar to type-erasure or protocol witness pattern, wrapping the behaviour of concrete implementations and delegating to them once the wrapper funcions are called.Declaration
Swift
public struct SubjectType<Element, ErrorType> where ErrorType : Error
-
Abstraction over subject types able to keep the last object (
See moreCurrentValueSubject
,BehaviorSubject
,MutableProperty
,Variable
) from reactive frameworks. This abstraction uses concept similar to type-erasure or protocol witness pattern, wrapping the behaviour of concrete implementations and delegating to them once the wrapper funcions are called.Declaration
Swift
public struct ReplayLastSubjectType<Element, ErrorType> where ErrorType : Error
-
The
ComposedMiddleware
is a container of inner middlewares that are chained together in the order as they were composed. Whenever anEventProtocol
or anActionProtocol
arrives to be handled by thisComposedMiddleware
, it will delegate to its internal chain of middlewares.It could be initialized manually by using the
init()
and configured by using the methodappend(middleware:)
, but if you’re ok with using custom operators you can compose two or more middlewares using the diamond operator:
See morelet composedMiddleware = firstMiddleware <> secondMiddleware <> thirdMiddleware
Declaration
Swift
public struct ComposedMiddleware<InputActionType, OutputActionType, StateType> : MiddlewareProtocol
extension ComposedMiddleware: Monoid
-
The
See moreIdentityMiddleware
won’t do any operation, simply bypass actions through. It’s meant to provide identity axiom to middleware type to allow its conformance to monoid algebra. It will simply forward actions to the next middleware in the chain or to the reducers. It can be useful for Unit Tests or for some compositions.Declaration
Swift
public struct IdentityMiddleware<InputActionType, OutputActionType, StateType> : MiddlewareProtocol, Equatable
-
This is a container that lifts a sub-state middleware to a global state middleware.
Internally you find the middleware responsible for handling events and actions for a sub-state (
Part
), while this outer class will be able to compose with global state (Whole
) in yourStore
.You should not be able to instantiate this class directly, instead, create a middleware for the sub-state and call
See moreMiddleware.lift(_:)
, passing as parameter the keyPath from whole to part.Declaration
Swift
public struct LiftMiddleware<GlobalInputActionType, GlobalOutputActionType, GlobalStateType, PartMiddleware> : MiddlewareProtocol where PartMiddleware : MiddlewareProtocol
-
This is a container that lifts a sub-state middleware to a global state middleware.
Internally you find the middleware responsible for handling events and actions for a sub-state (
Part
), while this outer class will be able to compose with global state (Whole
) in yourStore
.You should not be able to instantiate this class directly, instead, create a middleware for the sub-state and call
See moreMiddleware.liftToCollection(_:)
, passing as parameter the keyPath from whole to part.Declaration
Swift
@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) public struct LiftToCollectionMiddleware< GlobalInputActionType, GlobalOutputActionType, GlobalStateType, CollectionState: MutableCollection, PartMiddleware: MiddlewareProtocol>: MiddlewareProtocol where PartMiddleware.StateType: Identifiable, CollectionState.Element == PartMiddleware.StateType


Today I signed up for the Amazon Affiliate program. I suppose that because I have a variety of interests and tend to both research and purchase stuff related to those interests I may as well post about them with links to the relevant items.
For example, I'm typing this on a Macbook Pro Retina which I received as a graduation present about a year ago. My particular model is the one with a 13" screen, 16 gigs of RAM and a 512GB ssd. I've been very impressed with it. I had three specific requirements for a new laptop as a direct result of my previous one (a toshiba satellite). I wanted it to be small and light, excellent battery life, and a great trackpad. It has succeeded on all counts.
I'm sure I'll have more ideas about products in the future.
Feel free to email me with questions, inquiries, or to just say hello!


Polished
Muhammad Azamuddin
Profile
Setting
Sign Out
Home
Dashboard
Charts
Widget / UI
Forms
Buttons
Table
Colors
Font Sizes
LAYOUT OPTIONS
Two Columns
One Column
Profile
Setting
Sign Out
Setting
Forms
Quick Example
Full Name
Email Address
Example hints to explain more.
Password
Send me occasional newsletter
General Elements
Input
Input Disabled
Textarea
Type here...
Textarea Disabled
Type here...
Checkbox
Checkbox 1
Checkbox 2
Checkbox disabled
Radio
Radio 1
Radio 2
Radio disabled
Select
Option 1
Option 2
Option 2
Select disabled
Option 1
Option 2
Option 2
Select multiple
Option 1
Option 2
Option 2
Select multiple disabled
Option 1
Option 2
Option 2
Horizontal Form
Email
Password
Radios
First radio
Second radio
Third disabled radio
Checkbox
Example checkbox
Sign in
Input Sizes
Input addons
@
@example.com
Your vanity URL
https://example.com/users/
$
.00
With textarea
Validated Form
First name
Looks good!
Last name
Looks good!
Username
@
Please choose a username.
City
Please provide a valid city.
State
Please provide a valid state.
Zip
Please provide a valid zip.
Agree to terms and conditions
You must agree before submitting.
Submit form


Before Change
command_line = [command]
command_line.extend(arguments)
print((" ".join(command_line)))
try:
result = check_output(command_line, stderr=STDOUT)
return (0, str(result))
except CalledProcessError as error:
After Change
:rtype: (int, str or unicode)
:raises OSError: if there are problems running the command
with TemporaryFile(mode="w+", suffix="log") as stdouterr:
result = execute(command, arguments,
stdout=stdouterr, stderr=stdouterr)
stdouterr.seek(0)
log = stdouterr.readlines()
return (result, log)


Laxmi Agarwal (born 1 June 1990) was attacked in 2005 in New Delhi at the age of 15, after rebuffing the romantic advances of Naeem Khan. Her story, among others, was told in a series on acid attack victims by Hindustan Times.
She has since established grassroots campaigns for tackling the surge of acid attacks; one of her petitions has led the Supreme Court to order the central and state governments to regulate the sale of acid and the Parliament to enable easier prosecutions of acid attack perpetrators.
She was the former director of Chhanv Foundation, a NGO dedicated to help acid attack survivors in India


Blood Bank
| Blood Group | Hospital Name | Quantity | Contact |
|---|---|---|---|
| O+ | Govt. Hospital | 10 Units | Get in touch |
Logout
| Blood Group | Hospital Name | Quantity | Contact |
|---|---|---|---|
| O+ | Govt. Hospital | 10 Units | Get in touch |
| Name | Disease | View Prescription | Ammount | |
|---|---|---|---|---|
| ABC | Cancer | view |
20000 | Donate |


Simple tree from config. Click "Load me" nodes to load them
Simple tree from config. Click "[X]" to remove nodes.


To understand how the principles benefit people we first need to understand what the principles are. The principles that people looking to improve their learning experience need to understand are as follows: Use it to improve it. This is saying, the more you use that specific brain function the stronger the neuro paths will be. Repetition matters. Intensity matters. This is saying if you continue to ramp up the difficulty of the information you are learning you will see improvements in your learning capabilities. Time matters. This is saying changes occur at different times for each person. don’t compare yourself to others. In understanding these principles. You will stand to gain technically infinite knowledge provided you take the time to use and improve it and remember that repetition and intensity matter.
I feel like if I am to keep these principles in mind while I work it will help me push past the fixed mindset I think I have.
First you have to understand that currently people don’t know the full capabilities of the human brain. If you want to learn something you can. To increase your neuroplasticity you need to get into a few good habits. Some suggestions I have are to get good, quality sleep and drink a lot of water. You have to look after your mind as it is before you change how it works. Sticking to the principles mentioned above will also aid you significantly in your neuroplasticity journey.
I found this resources particularly helpful.
A growth mindset is the ability to take challenges head on and see them as an obstacle to overcome instead of seeing them as an insurmountable roadblock. A growth mindset is important to aid you in your learning journey. It turns “what's the point” thoughts into “what’s the solution” and feeds the curiosity the second question brings.
I noticed that I have a fixed mindset but I found the habits they suggest I get into to be very helpful. I am currently working on consciously changing my mindset.
I will be practicing self discipline and reminding myself when I inevitably fall into fixed mindset habits if the growth mindset habits I should be displaying. It will take a lot of intentionality and understanding of my emotional state at any time.
I found this resource particularly intriguing.


Introduction
1. Overview
1.1. Reactive Commons
The purpose of reactive-commons is to provide a set of abstractions and implementations over different patterns and practices that make the foundation of a reactive microservices architecture.
Even though the main purpose is to provide such abstractions in a mostly generic way such abstractions would be of little use without a concrete implementation so we provide some implementations in a best effors maner that aim to be easy to change, personalize and extend.
The first approach to this work was to release a very simple abstractions and a corresponding implementation over asyncronous message driven communication between microservices build on top of project-reactor and spring boot.
1.2. Project Reactor
Reactor is a highly optimized reactive library for building efficient, non-blocking applications on the JVM based on the Reactive Streams Specification. Reactor based applications can sustain very high throughput message rates and operate with a very low memory footprint, making it suitable for building efficient event-driven applications using the microservices architecture.
1.3. Reactive API for Event Mechanism
Reactive Commons is a reactive API for asyncronous message driven communication based on Reactor. Reactive Commons API enables messages to be published over a event bus like RabbitMQ or SNS/SQS and consumed using functional APIs with non-blocking back-pressure and low overheads. It enables applications using Reactor to use RabbitMQ or SNS/SQS as a message bus, integrating it with other systems to provide an end-to-end reactive system.
When we talk about asyncronous message driven communication, we can use several sematic ways to use the term "message". So, we can talk about Events, Commands and Queries.
1.3.1. Events - Pub/Sub
Events represent a fact inside the domain, it is the representation of a decision or a state change that a system want to notify to its subscribers. Events represents facts that nobody can change, so events are not intentions or requests of anything, An example may be and UserRegistered or a NotificationSent.
Events are the most important topic in a Publish-Subscribe system, because this element let’s notify a many stakeholders in a specific event. An other benefit is the system is decouple, because you can add more subscriber to the system without modify some component.
1.3.2. Commands
Commands represent a intention for doing something, that intention must to be done by the domain context with that responsibility. An example of a command may be: "registerUser" or "sendNotification".
1.3.3. Request / Reply
Queries represent a intention for getting information about something, that query must to be processed by the domain context with that responsibility and that context must respond with the information requested throught request/reply pattern. An example of a query may be: "UserInfo".
2. Getting Started
This quick start tutorial sets up a single node RabbitMQ and runs the sample reactive sender and consumer using Reactive Commons.
2.1. Requirements
You need Java JRE installed (Java 8 or later).
You also need to install RabbitMQ. Follow the instructions from the website.
2.1.1. Start RabbitMQ
Start RabbitMQ on your local machine with all the defaults (e.g. AMQP port is 5672).
2.1.2. Sample Spring Boot Application
The Spring Boot sample publishes and cosumes messages with the DomainEventBus
. This application illustrates how to configure Reactive Commons using RabbitMQ in a Spring Boot environment.
To build your own application using the Reactive Commons API, you need to include a dependency to Reactive Commons.
dependencies {
compile "org.reactivecommons:async-commons-rabbit-starter:0.6.2-ignored-value"
}
Also you need to include the name for your app in the application.properties:
spring.application.name=MyAppName
Or yaml format
spring:
application:
name: myAppName
DomainEventBus
You must enable DomainEventBus with the @EnableDomainEventBus annotation. It give you a DomainEventBus bean for emitting and listenning messages.
DomainEvent Class
The DomainEvent class has the following structure:
package org.reactivecommons.api.domain;
public class DomainEvent<T> {
private final String name;
private final String eventId;
private final T data;
//... getters, equals, hascode, toString impl..
}
A Main application may looks like:
import org.reactivecommons.async.impl.config.annotations.EnableDomainEventBus;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableDomainEventBus
public class MainApplication {
public static void main(String[] args) {
SpringApplication.run(MainApplication.class, args);
}
@Bean
public ManageTasksUseCase manageTasksUseCase(TaskToDoRepository tasks, DomainEventBus eventBus) {
return new ManageTasksUseCase(tasks, eventBus);
}
}
Where the ManageTasksUseCase expose some use cases of the domain.
public class ManageTasksUseCase {
private TaskToDoRepository tasks;
private DomainEventBus eventBus;
public ManageTasksUseCase(TaskToDoRepository tasks, DomainEventBus eventBus) {
this.tasks = tasks;
this.eventBus = eventBus;
}
public Mono<TaskToDo> createNew(String name, String description) {
return uuid()
.flatMap(id -> TaskToDoFactory.createTask(id, name, description))
.flatMap(tasks::save)
.flatMap(task -> emitCreatedEvent(task).thenReturn(task));
}
private Mono<Void> emitCreatedEvent(TaskToDo task) {
return Mono.from(eventBus.emit(new DomainEvent<>("task.created", task.getId(), task)));
}
//...
}
HandlerRegistry
Reactive commons has four types of listeners implemented, available to be registered in the application via the HandlerRegistry, each of them is designed to tackle common requirements for listeners in event based applications and abstracts the behavior of event flow in every situation .
A simple sample is:
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.beans.factory.annotation.Autowired;
@Configuration
public class SomeConfigurationClass {
@Autowired
private ManageTasksUseCase someBusinessDependency;
@Bean
public HandlerRegistry notificationEvents() {
return HandlerRegistry.register()
.listenEvent("task.created", event -> someBusinessDependency.functionReturningMonoVoid(event), EventClass.class);
}
}
2.1.3. Versioning
Reactive Commons used semver.org/
Reactive Commons uses a MAJOR.MINOR.PATCH
scheme, whereby an increment in:
-
MAJOR version when you make incompatible API changes,
-
MINOR version when you add functionality in a backwards compatible manner, and
-
PATCH version when you make backwards compatible bug fixes. Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format. == New & Noteworthy
2.2. What’s new in Reactive Commons 1.0
-
Introduction of the Reactive Commons API (DomainEvent, Command, DynamicRegistry, HandlerRegistry and DirectAsyncGateway classes/interfaces )
-
Support for request/reply pattern
-
Support for Direct Commands pattern
-
Support for Event pattern
-
Exception handling
-
Support for RabbitMQ
-
Support for SNS/SQS
Reference Documentation
3. Reactive Commons API
3.1. Overview
This section describes the reactive API for producing and consuming messages using Reactive Commons. There are three main classes in Reactive Commons:
-
HandlerRegistry
for listening to events and commands messages and for registering their respective handlers. -
DomainEventBus
for emiting events to an event bus -
DirectAsyncGateway
for emiting commands to an event bus
The project uses Reactor Core to expose a "Reactive Streams" API.
3.2. Semantic Messages Classes
Reactice Commons has 3 classes that represent events, commands or queries, giving a semantic meaning for a message. So, let’s talk about DomainEvent and Command classes .
3.2.1. DomainEvent<T>
:This class lets you represent a Event in the system. It accepts a generic class that will be the information to transport for that event, a eventId and a name for the event. The structure for a DomainEvent is
package org.reactivecommons.api.domain;
public class DomainEvent<T> {
private final String name;
private final String eventId;
private final T data;
public DomainEvent(String name, String eventId, T data) {
this.name = name;
this.eventId = eventId;
this.data = data;
}
//... getters, equals, hascode, toString impl..
}
3.2.2. Command<T>
An other basic structure is the Command class. This class lets you represent a Command in the system. It accepts a generic class that will be the information for that command, a commandId and a name for that event. The structure for a Command is:
package org.reactivecommons.api.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
@Data
@AllArgsConstructor
public class Command<T> {
private final String name;
private final String commandId;
private final T data;
}
3.2.3. AsyncQuery<T>
An other basic structure is the AsyncQuery class. This class lets you represent a Query in the system. It accepts a generic class that will be the information for that query and a name for that resoruce. The structure is:
@Data
public class AsyncQuery<T> {
private final String resource;
private final T queryData;
}
3.3. Reactive Commons - Sending Events, Commands and Request/Reply messages
Outbound messages are sent to an event bus using DomainEventBus
or DirectAsyncGateway
classes. If you are using Spring Boot, you can have a Main class like this:
import org.reactivecommons.async.impl.config.annotations.EnableDomainEventBus;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableDomainEventBus
@EnableDirectAsyncGateway
public class MainApplication {
public static void main(String[] args) {
SpringApplication.run(MainApplication.class, args);
}
@Bean
public ManageTasksUseCase manageTasksUseCase(TaskToDoRepository tasks, DomainEventBus eventBus) {
return new ManageTasksUseCase(tasks, eventBus);
}
}
3.3.1. DomainEventBus
The @EnableDomainEventBus annotation enable to the application to emit Events to the System. This annotation create a EnableDomainEventBus bean, so you can use it for emitting events. This interface looks like:
package org.reactivecommons.api.domain;
import org.reactivestreams.Publisher;
public interface DomainEventBus {
<T> Publisher<Void> emit(DomainEvent<T> event);
}
The emit method recive a DomainEvent<T> class where you can publish information to the system. The method will respond you in a reacive way with a Publisher, like a mono object. So, for example, if you want to send a UserRegistered event to the system ,you can do this:
public class AnyUseCase {
private DomainEventBus eventBus; // Injected
private Mono<Void> emitCreatedEvent(UserRegistered event) {
return Mono.from(eventBus.emit(new DomainEvent<>("user.registered", uuid(), event)));
}
//...
}
3.3.2. DirectAsyncGateway - Commands
If you want to send Commands to the system, the @EnableDirectAsyncGateway annotation enable to the application to emit Commands to the System. This annotation create a DirectAsyncGateway bean, so you can use it for emitting commands. This interface looks like:
public interface DirectAsyncGateway {
<T> Mono<Void> sendCommand(Command<T> command, String targetName);
<T, R> Mono<R> requestReply(AsyncQuery<T> query, String targetName, Class<R> type);
<T> Mono<Void> reply(T response, From from);
}
The sendCommand method recive a Command<T> class where you can publish information to the system. The method will respond you in a reacive way with a Publisher, like a mono object. So, for example, if you want to send a UserRegister command to the "target.name" component ,you can do this:
public class AnyUseCase {
private DirectAsyncGateway gateway; // Injected
private Mono<Void> emitCreatedEvent(UserRegister command) {
return gateway.sendCommand(new Command<>("user.register", uuid(), command), "target.name") // Continue reactive flow
}
//...
}
The second parameter for sendCommand method is the name of the target component for that command, It’s the name stablished in the properties file of Spring "application.properties" in the "spring.application.name" field.
| you don’t need this parameter in the emit method of DomainEventBus class, because an event is a fact for cero or more subscribers. |
3.3.3. DirectAsyncGateway - Request/Reply
The DirectAsyncGateway class has another method called "requestReply", this method lets you to send a query and wait for an answer for that query. The method will respond you in a reacive way with a Publisher, like a mono object with the generic data. So, for example, if you want to send a query with QueryUser data, to the "target.name" component and recive an User object response, you can do this:
public class AnyUseCase {
private DirectAsyncGateway gateway; // Injected
private Mono<User> query(QueryUser query) {
return gateway.requestReply(new AsyncQuery<>("query.name", query), "target.name", User.class);
}
//...
}
3.4. Reactive Commons - Listening for Events, Commands and Query messages
3.4.1. HandlerRegistry
Inbound messages are listened from an event bus using HandlerRegistry
class. The @EnableMessageListeners annotation enable you to listen messages like Events, Commands or Queries. You have to create a HandlerRegistry object, so you can register handlers for specifc messages.
@SpringBootApplication
@EnableMessageListeners
public class MainApplication {
...
}
The HandlerRegistry implements builder patter, so each time you use some method, it will return a HanlderRegistry object. HanlderRegistry has the following methods:
-
listenEvent: It lets listen for an event
-
serveQuery: It lets listen for a query
-
handleCommand: It lets listen for a command
HandlerRegistry - listenEvent
listenEvent method lets you register a handler for a specific event. It has the next signature:
HandlerRegistry listenEvent(String eventName, EventHandler<T> fn, Class<T> eventClass)
Where the EventHandler interface signature is:
public interface EventHandler<T> extends GenericHandler<Void, DomainEvent<T>> {
}
public interface GenericHandler<T, M> {
Mono<T> handle(M message);
}
| The return type of the EventHandler is Void |
So, for example, if your application want react to user.registered event, you can define a handler for that event like this:
@Configuration
public class SomeConfigurationClass {
@Autowired
private ManageTasksUseCase someBusinessDependency;
@Bean
public HandlerRegistry eventMessages() {
return HandlerRegistry.register()
.listenEvent("user.registered", event -> someBusinessDependency.functionReturningMonoVoid(event), UserRegistered.class)
}
}
HandlerRegistry - handleCommand
handleCommand method lets you register a handler for a specific command. It has the next signature:
HandlerRegistry handleCommand(String commandName, CommandHandler<T> fn, Class<T> commandClass)
Where the CommandHandler interface signature is:
public interface CommandHandler<T> extends GenericHandler<Void, Command<T>> {
}
public interface GenericHandler<T, M> {
Mono<T> handle(M message);
}
| The return type of the CommandHandler is Void |
So, for example, if your application want react to user.register command, you can define a handler for that command like this:
@Bean
public HandlerRegistry commandMessages() {
return HandlerRegistry.register()
.handleCommand("user.register", cmd -> someBusinessDependency.handleCommand(cmd), UserRegister.class);
}
HandlerRegistry - serveQuery
serveQuery method lets you register a handler for a specific query. It has the next signatures:
HandlerRegistry serveQuery(String resource, QueryHandler<T, R> handler, Class<R> queryClass)
HandlerRegistry serveQuery(String resource, QueryHandlerDelegate<Void, R> handler, Class<R> queryClass)
Where the QueryHandler interface signature is:
public interface QueryHandler<T, C> extends GenericHandler<T, C> {
}
public interface GenericHandler<T, M> {
Mono<T> handle(M message);
}
The QueryHandlerDelegate interface signature is:
public interface QueryHandlerDelegate<T, M> {
Mono<T> handle(From from, M message);
}
| The return type of the QueryHandler is a generic C |
For example, if your application want react to user.information query, you can define a handler for that query like this:
@Bean
public HandlerRegistry queryMessages() {
return HandlerRegistry.register()
.serveQuery("user.information", query -> someBusinessDependency.findSomething(query), SomeQuery.class);
}
| The return type of the QueryHandlerDelegate should be Void |
This second interface allows the request / reply pattern not to have to be resolved in the same flow. For example, when the execution of a task is requested, and it can be processed by a group of workers, who leave the result in a database. There is another group of workers who are in charge of listening to the changes in the database and responding to that request. In this scenario, the process who receives the request is not the same process who responds to it. That is the usage scenario for QueryHandlerDelegate:
@Bean
public HandlerRegistry queryMessages() {
return HandlerRegistry.register()
.serveQuery("report.create", (from, query) -> someTask.startReportProcess(from, query), SomeQuery.class);
}
When the report creation task is completed, the process responsible of responding should call the reply method of DirectAsyncGateway passing the from object like this:
gateway.reply(response, from)
| Remember HandlerRegistry use builder pattern, So, you can build a chain of listener for each message: |
@Configuration
public class SomeConfigurationClass {
@Autowired
private ManageTasksUseCase someBusinessDependency;
@Bean
public HandlerRegistry notificationEvents() {
return HandlerRegistry.register()
.listenNotificationEvent("some.event.name", event -> someBusinessDependency.someFunctionReturningMonoVoid(event), SomeClass.class)
.listenEvent("some.event.name2", event -> someBusinessDependency.functionReturningMonoVoid(event), Some.class)
.serveQuery("query.name", query -> someBusinessDependency.findSomething(query), SomeQuery.class)
.handleCommand("command.name", cmd -> someBusinessDependency.handleCommand(cmd), CmdClass.class);
}
}
HandlerRegistry - patterns
You can also define some handlers with names that contains a wildcard, which will be useful in some cases, for example you can:
@Configuration
public class SomeConfigurationClass {
@Autowired
private ManageTasksUseCase someBusinessDependency;
@Bean
public HandlerRegistry notificationEvents() {
return HandlerRegistry.register()
.listenNotificationEvent("some.event.name", event -> someBusinessDependency.someFunctionReturningMonoVoid(event), SomeClass.class)
.listenEvent("some.event.name2", event -> someBusinessDependency.functionReturningMonoVoid(event), Some.class)
.serveQuery("*.some.query", query -> someBusinessDependency.findSomething(query), SomeQuery.class)
.handleCommand("command.pattern.*", cmd -> someBusinessDependency.handleCommand(cmd), CmdClass.class);
}
}
| * can be any character sequence, but the fixed words have priority, for example if exists two rules like "prefix.*" and "*.*" and receives a name like "prefix.name", handler with "prefix.*" will be called. |


We admit, it's hard to define what Customs is. It's a night, but it's also a feeling and a vibe. The most important thing you should know is that we're devoted to bringing the freshest in electronic music to Seattle's dance floors. We aim to present something different each and every time, all curated by the Customs crew members, who have their ears to the ground when it comes to what's new and exciting in dance music.