Mask Network is an open-source project building on the existing social networks. We focus on protecting users’ privacy and rights. Hope that with the collective power of our communities and developers, we could create a better experience for the users, and bridge Web 2.0 and Web 3.0.
For now, Mask Network has already created 16 bounties on Gitcoin — 3 completed and 13 still under development. 5 new bounties are listed as follows:
Check this article for details of our first bounty list:
Mask Network Bounty List
Mask Network is an open-source project building on the existing social networks. We hope that with the collective power…
masknetwork.medium.com
1: Integrate Mask Network in Minds.com
https://github.com/DimensionDev/Maskbook/issues/2323
Platform: Gitcoin
Experience: Advanced
Category: Mask Plugin
Time Commitment: 1 month
Bounty Size: 2500 USD
Part 1: Problem Description
Minds is an alt-tech blockchain-based social network. Users can earn money or cryptocurrency for using Minds, and tokens can be used to boost their posts or crowdfund other users. Minds has been described as more privacy-focused than mainstream social media networks. (source: Wikipedia)
We are cooperating with Minds and our goal is to integrate the entire function into Minds so that the existing Minds users can use the same functionality and interface as we have in Twitter and Facebook, including the encryption & decryption and the plugin execution environment.
We are expecting developers to have a strong knowledge in what Mask Network can do so please do research before applying. Thank you.
Part 2: Resources
Or ask questions on telegram @ here:
2: Enhance the File Service with ArDrive.io
https://github.com/DimensionDev/Maskbook/issues/2362
Platform: Gitcoin
Experience: Intermediate
Category: Mask Plugin
Time Commitment: 4 weeks
Bounty Size: 2000 USD
Part 1: Problem Description
ArDrive is a suite of file sync apps that let users pay once to store their data forever on Arweave. Our web and desktop apps focus on the core features of file sync like uploading and downloading, while giving the best security for private files and integrating with Arweave wallets for payments.
Mask Network is a browser extension that allows users to create encrypted posts and choose who is able to decrypt. Built upon this access control system and the capability of injecting any DOM elements into any social media, Mask Network creates an open market that welcomes everyone to create their own Dapplet or plugin on their favorite platforms.
We need help bringing the gap between Web 2 apps and ArDrive. ArDrive-Connect gives other web applications a standard set of libraries and interfaces that lets them connect their app and users into the ArDrive. Applications that connect with ArDrive can give their users the ability to upload, download and share their files from the PermaWeb. We have partnered with Mask Network to deliver this capability in their social network applications, so their users can easily leverage the PermaWeb for file sharing.
The detailed description including the user stories can be here：
Part 2: Resources
https://github.com/DimensionDev/Maskbook
https://github.com/ardriveapp/docs/blob/main/ArweaveFileSystem.md
Part 3: Contact and Support:
ArDrive Discord Server
Mask Discord Server
<EMAIL_ADDRESS>4: Replace Twitter Profile Header Photo with any Media Type
https://github.com/DimensionDev/Maskbook/issues/2236
Platform：Gitcoin
Experience：Intermediate
Category：Mask Plugin
Time Commitment：2 Weeks
Bounty Size：1000 DAI
Part 1: Problem Description
Inspired by Twitter user @Prathkum, I think it’s worth adding something similar to our Mask Network users by enabling decorating your Twitter header with any media type, e.g., a gif, a video or even an html5 page. We would like you to explore a possible solution yourself, although I do have an idea in my mind. Please propose your idea here and I will share my thoughts with you in the end.
3. Unlock the Imagination of Online Publication Directly on Twitter with Unlock Protocol
https://github.com/DimensionDev/Maskbook/issues/2363
Platform: Gitcoin
Experience: Intermediate
Category: Mask Plugin
Time Commitment: 4 Weeks
Bounty Size: 2000 USD
Part 1: Problem Description
Mask Network offers a browser extension which lets users create encrypted tweets where the content of the tweet can only be “viewed” by other Twitter users if they use the Mask Network browser extension. These tweets can include text, but also images.
Unlock is a protocol for memberships which lets creators deploy a lock and sell access to this lock using the Ethereum blockchain. Locks can be added to websites, or applications in order to monetize them.
We are proposing an integration between Unlock and Mask Network where creators will be able to post encrypted tweets and put them “behind” a lock, so that only members of the lock are able to view their content. If viewers are not members, then, Mask Network would offer the ability to Unlock these memberships. In that scenario, Mask Network is a referrer and should earn UDT.
For a more detailed description, you can refer to this.
Part 2: Resources
https://github.com/unlock-protocol/unlock
4.Bluesky “Ecosystem Review” Translation
https://github.com/DimensionDev/Maskbook/issues/2296
Platform: Gitcoin
Experience: Beginner
Category: Other
Time Commitment: 15 Days
Bounty Size: 500 DAI
Part 1: Problem Description
Twitter CEO Jack Dorsey has announced a new research team called Bluesky on December 11, 2019, which was an initiative to develop an open and decentralized standard for social media. On January 22, Bluesky released a 61-page review named <Ecosystem Review> . This Review was an overview of the most viable decentralized social network protocols and apps.
With the sponsor of Mask Network, Fat Garage will launch the first bounty: Translating the Bluesky’s into Mandarin.
The whole translation will be processed on the Roamsearch.
Part 2: Resources
Ecosystem Review
https://coywolf.media/file/coywolf/pdf/decentralized-social-ecosystem-review.pdf
Roam for Micro-Tasking — Make 1st Digital $ Together
https://roamresearch.com/#/app/fat-garage/page/VvOZ0xzzF
Part 3: Contact and Support:
E-mail<EMAIL_ADDRESS>5. Clubhouse on top of Twitter
https://github.com/DimensionDev/Maskbook/issues/2375
Platform: Gitcoin
Experience: Advanced
Category: Mask Plugin
Time Commitment: 4 weeks
Bounty Size: 2500 USD
Part 1: Problem Description
Clubhouse has gone viral on the Internet the past week, everywhere in the world. It shows the potential of a socialized audio-only chat room. The success of the Clubhouse is not simply relying on its core audio chat feature. It consists of quite a lot of tweaks and details on their design. Therefore, this bounty is not to copy it. Instead, we just want to show the potential of Mask Network, being a middle layer on the existing Internet, that can integrate an audio chat room directly on top of Twitter with minimal efforts.
The idea is to inject a chat room in a single tweet, where each person who sees it and have Mask Network installed can choose to join the room to listen to the discussion, or, raise their hand to speak. In another word, each tweet is a unique chat room, which is designed to be one, with the audio chat functionality. This plugin basically turns each RESTFUL tweet into a REAL TIME discussion. On top of a social media with enough social feature plus the access control system provided by Mask Network, I believe this would bring our users an alternative choice on the existing social media and it should also bring our (potential) developers more creativeness on how we can play with Mask Network.
Part 2: Resources
https://www.joinclubhouse.com/
https://github.com/bestony/neshouse -> an open-source implementation by @bestony in 55 hours
If you’re interested in any of our bounties, please contact us on:
Telegram: t.me/maskbook_group
Discord: discord.gg/4SVXvj7
Github https://github.com/DimensionDev
Twitter https://twitter.com/realMaskNetwork
Facebook https://www.facebook.com/masknetwork
Discord https://discord.com/invite/cKGW45g
Telegram (English) https://t.me/maskbook_group
Telegram （中文） https://t.me/masknetwork_cn


Forsikring Nord
Member Status
x
fullName
Epost
tlf
Adresse
kunde Nummer
misc
Married
2 kids
Jane Smith
Forsikring
Hello
Faktura
Still Here?


z– layout: post title: A Brief Introduction to Information Geometry. date: 2017-06-05 categories: reinforcement_learning —
A biased coin. Such a thing does not actually exist, but let’s suspend our disbelief for the duration of this discussion.
I have handed you a biased coin. The coin has an unknown probability, , of coming up , and probability of coming up .
We humans have a natural inclination to learn. Even the dullest among us, at an early age…


user id
password
To show more properties than curl/postman:
Firefox - tools - web developer - storage inspector - cookies - select item


{% extends "base.html" %} {% block content %}
- {{community.description}}
created by /u {{community.owner}}, has {{community.subscribers.count}} subscribers
location - {{community.location}}
{{post.description}}
{{post.title}} by {{post.author}} on {{post.creation_date}} has {{post.views.count}} views
{{post.description}}


UAAG Home
The UAAG Alliance (United Airlines Association Global) is an alliance originating from AM4 (airline4.net). The alliance is a few months old. There are multiple admins:
IV International Airways (The founder and CEO (Chief Executive Officer))
Orbit
vAirlines (The COO (Chief Operations Officer))
Shorts Stream (The CPAO (Chief People and Admin Officer))
Sands Beach Airways (Organizer)
High Flyin Skyy (Public Relations Officer)
The alliance has many members and is quickly
growing in size and value.
To contact us, you can join our discord and ask the question, or you can contact an admin in the AM4 app/website.
This webpage was started on Tuesday, May 26, 2020 A.D./C.E. We are not responsible for damage or harm to yourself, another person, an animal, or an object, from this website. We are not liable for anything involving this website, and we are especially
not liable for anything not involving this website. According to the MIT License,
commercial use, modification, distribution, and private use are allowed under the condition that it contains the MIT license and a copyright notice.
The MIT License also prevents us from being liable and no warranties may be given.
Powered by CirclR.


{{::vm.translate.get('Note that the updated translations only be affected after the application is restarted')}}


{% extends "template.html" %} {% block head %} {% endblock %} {% block main %}
This page lists the default mime types and headers set by Mu Server as of version {{version}}.
If there is no extension, then application/octect-stream
is used or you can
customize these values.
| Mime Type | Extensions | Gzipped | Response Headers |
|---|---|---|---|
| {{ type.mimeType }} | {{ type.extensions | raw }} | {{ type.gzip }} | {{ type.headers | raw }} |


--- title: "Kernel Density Plot" date: "2018-05-15" output: html_document ---
library(tidyverse)
library(readr)
library(ggthemes)
moma <- read_csv("http://bit.ly/cs631-moma")
moma_year <- moma %>%
mutate(acq_yr_vs_death_yr = case_when(
year_acquired < artist_death_year ~ "before artist's death, \nand artist has since died",
year_acquired > artist_death_year ~ "after artist's death",
year_acquired == artist_death_year ~ "same year as artist's death",
is.na(artist_death_year) == TRUE ~ "before artist's death,\nbut artist is still alive")) %>%
drop_na(acq_yr_vs_death_yr)
ggplot(moma_year, aes(year_acquired)) +
geom_density(fill = 'thistle3',
alpha = .5,
na.rm = TRUE) +
facet_wrap(~acq_yr_vs_death_yr) +
labs(x = "Year Acquired", y = "Density",
subtitle = "Year of Artist's Death vs. Year Acquired",
title = "MoMA Paintings, Acquirement Trends")
A density plot, a smoothed version of a histogram, is a visualization of the distribution of a continuous variable. This density plot was created with ggplot2::geom_density
, which uses kernel density estimation for smoothing.
The data used to make this graph is Dr. Alison Presmanes Hill’s cleaned [version] (http://bit.ly/cs631-moma) of MoMA’s collection dataset. MoMA’s original version is publicly available on GitHub.
The dataset contains 23 variables in total, with each entry corresponding to a piece of artwork in MoMA’s collection. Information is included about the artist of each piece, such as a brief bio, birth year, death year, and gender. The number of artists associated with each piece is also provided, with this number further broken down into number of female artists and number of male artists. Also included in the dataset is the year the piece was created, the year it was acquired by MoMA, whether it was acquired by MoMA as a purchse, gift, or exchange, details of the dimensions of the piece, and information about the medium of the artwork.
The audience for this plot might be individuals or organizations who are members of MoMA and are interested in the types of artwork that MoMA adds to its collection, specifically in the artists of these pieces.
I wanted to explore the relationship between the year a piece was acquired by MoMA and the year that the artist of the piece died to see if there were any trends that appeared over time. There are four scenarios depicted in the different facets:
A density plot is a smoothed version of a histogram plot, so one way to interpret these plots is by focusing on the height. The taller the density function for a given facet at a given year, the more paintings that fall under that scenario were acquired by MoMA that year. The shorter the density function, the less paintings of that scenario were acquired that year. As for what to look for, one thing to look at is how the height of the density functions change over the years and if there are any obvious trends.
Annotation: The density values for each of the facets at a particular year could be included with annotation to emphasize differences between the separate plots.
Color: Instead of using facet wrap to separate the plots, the four plots could all be included on a single graph with color distinguishing the different categories.
General Composition: Histograms could be included underneath the density plots to add another layer of information to the visualization.
Violin plots are another popular type of density plot. A violin plot is a box plot that uses density plots instead of the traditional boxes. The density plots are rotated and reflected, with some of the summary statistics included in traditional box plots on top.
To make this plot I created an additional variable, acq_yr_vs_death_yr
, which describes the relationship between the year a piece was acquired by MoMA and the year that the artist died (if applicable). This variable was then used to separate the paintings into the four different scenarios with facet_wrap
so that each would have its own plot. The kernel density estimate plots were created with ggplot2::geom_density
, with the year the paintings were acquired as the y-value.


Secura - store passwords securely
This weekend I decided to study more about hashing and thought of creating my own hashing function, which would obviously, hash. Hashing is different from encryption, with encryption you can decrypt the message into the original form, but hashing should be one way, i.e no matter what the output is, it should be irreversible, which makes the problem even harder. I ended up creating my own hashing algorithm, which I was able to crack myself in around 20 minutes or so. I further studied about how dangerous it can be to roll your own hash (yes roll your hash) if you are not a cryptographic expert so I decided to give up on creating my own hashing algorithm, however I did dig deep on how hashing is used to store passwords.
Well, of course, good hashing algorithms exist which are one way (SHA-512, SHA-256, and MD5) however they are crackable. By crackable I mean, although the hash itself is irreversible the hackers calculate the hash of tons(^tons) of common words, and compare it with the existing hash. The process is repeated for every possible word, until they match some passwords. That is exactly why when we choose a password, we are asked to choose a long (7+ digits) with special characters, since the more complicated the password is, the more time it will take to brute force it. Ofcourse, even after all these complications, hackers are still able to crack the passwords. There are many different attacks which the hackers use to crack them such as : Rainbow Table, Dictionary, Brute Force attacks which poses a great security threat to the users.
While creating my node app, I found out that it was difficult for me to choose a hashing algorithm which is secure for storing my passwords, and understanding about cryptography took a lot of time. I believe that it should not be necessary for someone to be a cryptographic expert to hash their passwords securely, hence I created a library : Secura which one can use to hash the passwords securely and compare the asynchronous way. This module returns a promise with the hashed password and also compares it.
Below I have described the usage :
Usage
Install the module :
npm install secura
Usage is very simple and straightforward. You can import the module using :
const secura = require('secura');
Generate Password
This converts the user password to a secure hash.
secura.generatePassword(password)
.then(hash=>{
//store the hash in the database
});
Verify Password
This verifies if the password entered by the user matches the hashed password stored in the database.
secura.validatePassword(password, hash)
.then(isMatch=>{
//returns true if password matches and false otherwise
})
Features
- Simple and straightforward to use. No knowledge of cryptography required to hash passwords and compare.
- Every hashed password is 61 digits long.
- Protection from Brute Force & Dictionary Attacks.
- Protection from Rainbow Table Attacks.
- Randomly generated salt for every password.
- Extra field is not required for storing salt in the database.
- Uses PBKDF2 to compute hash.
You can contribute to this library by sending a pull request or opening an issue at : repo link
Thanks for reading. Hoping you will find this library useful.
Powered by Jekyll


Modules
| ReplicatedStorage.LocalSource.Publishers.ClientRequestSender | For client-to-server communication. |
| ReplicatedStorage.SharedSource.Data.Armies.Army | Represents of group of units of any type and Generals. |
| ReplicatedStorage.SharedSource.Data.Battle | Container for battle data. |
| ReplicatedStorage.SharedSource.Data.Cities.City | Cities are places for garrison and can be captured. |
| ReplicatedStorage.SharedSource.Data.GameTeam | Container for team information and Players |
| ReplicatedStorage.SharedSource.Data.Generals.General | Initializer for a new General. |
| ReplicatedStorage.SharedSource.Data.Library.GameObject | Base class for objects that have a CFrame cframe and string team_color All GameObjects can be listened to for data changes. |
| ReplicatedStorage.SharedSource.Data.Structures.Structure | Create a new Structure. |
| ReplicatedStorage.SharedSource.Data.Territories.Territory | Base class for all Territory types. |


Deprecated: This routine has been superseded by the CSPICE routine
cspice_limbpt. This routine is supported for purposes of backward
compatibility only.
CSPICE_LIMB_PL02 returns a set of points on the limb of a specified
target body, where the target body's surface is represented by a
triangular plate model contained in a type 2 DSK segment.
Given:
handle the DAS file handle of a DSK file open for read
access. This kernel must contain a type 2 segment that
provides a plate model representing the entire surface
of the target body.
[1,1] = size(handle); int32 = class(handle)
dladsc the DLA descriptor of a DSK segment representing the
surface of a target body.
[SPICE_DLA_DSCSIZ,1] = size(dladsc)
int32 = class(dladsc)
target the name of the target body. `target' is
case-insensitive, and leading and trailing blanks in
`target' are not significant. Optionally, you may supply
a string containing the integer ID code for the object.
For example both 'MOON' and '301' are legitimate strings
that indicate the moon is the target body.
This routine assumes that a kernel variable representing
the target's radii is present in the kernel pool.
Normally the kernel variable would be defined by loading
a PCK file.
[1,c1] = size(target); char = class(target)
or
[1,1] = size(target); cell = class(target)
et the epoch of participation of the observer,
expressed as ephemeris seconds past J2000 TDB: `et' is
the epoch at which the observer's position is
computed.
When aberration corrections are not used, `et' is also
the epoch at which the position and orientation of the
target body are computed.
When aberration corrections are used, `et' is the epoch
at which the observer's position relative to the solar
system barycenter is computed; in this case the position
and orientation of the target body are computed at
et-lt, where `lt' is the one-way light time between the
target body's center and the observer. See the
description of `abcorr' below for details.
[1,1] = size(et); double = class(et)
fixfrm the name of the reference frame relative to which the
output limb points are expressed. This must a
body-centered, body-fixed frame associated with the
target. The frame's axes must be compatible with the
triaxial ellipsoidal shape model associated with the
target body (normally provide via a PCK): this routine
assumes that the first, second, and third ellipsoid radii
correspond, respectively, to the x, y, and z-axes of the
frame designated by `fixfrm'.
[1,c2] = size(fixfrm); char = class(fixfrm)
or
[1,1] = size(fixfrm); cell = class(fixfrm)
`fixfrm' may refer to a built-in frame (documented in
the Frames Required Reading) or a frame defined by a
loaded frame kernel (FK).
The orientation of the frame designated by `fixfrm' is
evaluated at epoch of participation of the target
body. See the descriptions of `et' and `abcorr' for
details.
abcorr indicates the aberration correction to be applied
when computing the observer-target position, the
orientation of the target body, and the target-
source position vector.
[1,c3] = size(abcorr); char = class(abcorr)
or
[1,1] = size(abcorr); cell = class(abcorr)
`abcorr' may be any of the following.
'NONE' Apply no correction. Compute the limb
points using the position of the observer
and target, and the orientation of the
target, at `et'.
Let `lt' represent the one-way light time between the
observer and the target body's center. The following
values of `abcorr' apply to the "reception" case in
which photons depart from the target body's center at
the light-time corrected epoch et-lt and *arrive* at
the observer's location at `et':
'LT' Correct for one-way light time (also
called "planetary aberration") using a
Newtonian formulation. This correction
yields the location of the limb points at
the approximate time they emitted photons
arriving at the observer at `et' (the
difference between light time to the
target center and light time to the limb
points is ignored).
The light time correction uses an
iterative solution of the light time
equation. The solution invoked by the
'LT' option uses one iteration.
The target position as seen by the
observer and the rotation of the target
body are corrected for light time.
'LT+S' Correct for one-way light time and stellar
aberration using a Newtonian formulation.
This option modifies the position obtained
with the 'LT' option to account for the
observer's velocity relative to the solar
system barycenter. The result is the
apparent limb as seen by the observer.
'CN' Converged Newtonian light time correction.
In solving the light time equation, the
'CN' correction iterates until the
solution converges. The position and
rotation of the target body are corrected
for light time.
'CN+S' Converged Newtonian light time
and stellar aberration corrections.
obsrvr the name of the observing body. This is typically
a spacecraft, the Earth, or a surface point on the
Earth. `obsrvr' is case-insensitive, and leading and
trailing blanks in `obsrvr' are not significant.
Optionally, you may supply a string containing the
integer ID code for the object. For example both
'EARTH' and '399' are legitimate strings that indicate
the Earth is the observer.
[1,c4] = size(obsrvr); char = class(obsrvr)
or
[1,1] = size(obsrvr); cell = class(obsrvr)
npoints the number of limb points to compute.
[1,1] = size(npoints); int32 = class(npoints)
For values of `npoints' less-than or equal-to zero,
the output arguments return as zeros and empty arrays.
the call:
[trgepc, obspos, limbpts, plateids] = ...
cspice_limb_pl02( handle, dladsc, target, ...
et, fixref, abcorr, ...
obsrvr, npoints )
returns:
trgepc the "target epoch." `trgepc' is defined as follows:
letting `lt' be the one-way light time between the
target center and observer, `trgepc' is either the
epoch et-lt or `et' depending on whether the requested
aberration correction is, respectively, for received
radiation or omitted. `lt' is computed using the
method indicated by `abcorr'.
[1,1] = size(trgepc); double = class(trgepc)
`trgepc' is expressed as seconds past J2000 TDB.
obspos the vector from the center of the target body at
epoch `trgepc' to the observer at epoch `et'. `obspos' is
expressed in the target body-fixed reference frame
`fixfrm', which is evaluated at `trgepc'.
[3,1] = size(obspos); double = class(obspos)
`obspos' is returned to simplify various related
computations that would otherwise be cumbersome. For
example, the vector `xvec' from the observer to the
Ith limb point can be calculated via the expression
xvec = imbpts(:,i) - obspos
The components of `obspos' are given in units of km.
limbpts an array of points on the limb of the target.
[3,npoints] = size(limbpts); double = class(limbpts)
The ith point is contained in the array elements
limbpts(:,i)
As described above, each limb point lies on a ray
emanating from the center of the target and passing
through a limb point on the target's reference
ellipsoid. Each limb point *on the reference ellipsoid*
is the point of tangency of a ray that emanates from the
observer. Measured in a cylindrical coordinate system
whose Z-axis is parallel to the observer-target vector,
the magnitude of the separation in longitude between the
limb points is
2*Pi / npoints
The limb points are expressed in the body-fixed
reference frame designated by `fixfrm'; the
orientation of the frame is evaluated at `trgepc'.
Units are km.
plateIDs an array of integer ID codes of the plates on which
the limb points are located. The ith plate ID
corresponds to the ith limb point. These ID codes can
be use to look up data associated with the plates, such
as the plates' vertices or outward normal vectors.
[1,npoints] = size(plateIDs); int32 = class(plateIDs)
Any numerical results shown for this example may differ between
platforms as the results depend on the SPICE kernels used as input
and the machine specific arithmetic implementation.
In the following example program, the file
phobos_3_3.dsk
is a DSK file containing a type 2 segment that provides a plate model
representation of the surface of Phobos. The file
mar097.bsp
is a binary SPK file containing data for Phobos, the Earth, and the
Sun for a time interval bracketing the date
2006 NOV 3 00:00:00 UTC.
pck00010.tpc is a planetary constants kernel file containing radii
and rotation model constants. naif0010.tls is a leapseconds kernel.
All of the kernels other than the DSK file should be loaded via
a meta-kernel. An example of the contents of such a kernel is:
KPL/MK
\begindata
KERNELS_TO_LOAD = ( 'naif0010.tls'
'pck00010.tpc'
'mar097.bsp' )
\begintext
Example:
%
% Compute a set of limb points on Phobos as seen from Mars. Perform
% a consistency check using the emission angle at each point,
% where the emission angle is computed using both a reference
% ellipsoid and the actual plate model surface and surface normal.
% We expect to see an emission angle of approximately 90 degrees.
%
% Version 1.0.0 18-MAR-2014 (NJB)
%
function limb_pl02_t
%
% Constants
%
NPOINTS = 3;
TIMLEN = 40;
TOL = 1.d-12;
UTCSTR = '2007 FEB 9 00:00:00 UTC';
%
% Initial values
%
target = 'Phobos';
abcorr = 'CN+S';
fixfrm = 'IAU_PHOBOS';
obsrvr = 'Mars';
%
% Prompt for the name of a meta-kernel specifying
% all of the other kernels we need. Load the
% meta kernel.
%
meta = input( 'Enter meta-kernel name > ','s');
cspice_furnsh( meta )
%
% Prompt for the name of a DSK file.
%
dsk = input( 'Enter DSK name > ','s');
%
% Open the DSK file for read access.
% We use the DAS-level interface for
% this function.
%
handle = cspice_dasopr( dsk );
%
% Begin a forward search through the
% kernel, treating the file as a DLA.
% In this example, it's a very short
% search.
%
[dladsc, found] = cspice_dlabfs( handle );
if ~found
%
% We arrive here only if the kernel
% contains no segments. This is
% unexpected, but we're prepared for it.
%
fprintf( 'No segments found in DSK file %s\n', dsk )
return
end
%
% If we made it this far, `dladsc' is the
% DLA descriptor of the first segment.
%
% Now compute sub-points using both computation
% methods. We'll vary the aberration corrections
% and the epochs.
%
et = cspice_str2et( UTCSTR );
timstr = cspice_timout( et, ...
'YYYY-MON-DD HR:MN:SC.### ::TDB(TDB)' );
fprintf( '\n\n' )
fprintf( ' Observer: %s\n', obsrvr )
fprintf( ' Target: %s\n', target )
fprintf( ' Observation epoch: %s\n', timstr )
fprintf( ' Aberration correction: %s\n', abcorr )
fprintf( ' Body-fixed frame: %s\n', fixfrm )
%
% Now compute grid of limb points.
%
[trgepc, obspos, limbpts, plateIDs] = ...
cspice_limb_pl02( handle, dladsc, target, ...
et, fixfrm, abcorr, ...
obsrvr, NPOINTS );
%
% Display the limb points.
%
for i = 1:NPOINTS
[radius, lon, lat] = cspice_reclat( limbpts(:,i) );
fprintf( '\n' )
fprintf( ' Limb point: %d \n', i )
fprintf( ' Radius (km): %f\n', ...
radius)
fprintf( ' Planetocentric longitude (deg): %f\n', ...
lon * cspice_dpr() )
fprintf( ' Planetocentric latitude (deg): %f\n', ...
lat * cspice_dpr() )
fprintf( ' Plate ID: %d\n', ...
plateIDs(i) )
%
% Compute the illumination angles using an ellipsoidal
% representation of the target's surface. The role of
% this representation is to provide an outward surface
% normal.
%
[phase, solar, emissn] = cspice_illum( target, et, abcorr, ...
obsrvr, limbpts(:,i) );
fprintf( ' emission angle derived using\n' )
fprintf( ' - an ellipsoidal ' )
fprintf( 'reference surface (deg): %f\n', ...
emissn * cspice_dpr() )
%
% Compute the illumination angles at the limb point
% using the actual plate model surface normal.
%
[phase, solar, emissn] = cspice_illum_pl02( handle, dladsc, ...
target, et, abcorr, obsrvr, ...
limbpts(:,i) );
fprintf( ' - plate model''s ' )
fprintf( 'surface and normal vector (deg): %f\n', ...
emissn * cspice_dpr() )
end
%
% Close the DSK file. Unload all other kernels as well.
%
cspice_dascls( handle )
cspice_kclear
MATLAB outputs:
Observer: Mars
Target: Phobos
Observation epoch: 2007-FEB-09 00:01:05.184 (TDB)
Aberration correction: CN+S
Body-fixed frame: IAU_PHOBOS
Limb point: 1
Radius (km): 11.563501
Planetocentric longitude (deg): 91.739066
Planetocentric latitude (deg): -0.000811
Plate ID: 229468
emission angle derived using
- an ellipsoidal reference surface (deg): 90.001006
- plate model's surface and normal vector (deg): 110.821665
Limb point: 2
Radius (km): 9.537023
Planetocentric longitude (deg): -87.847223
Planetocentric latitude (deg): 59.998792
Plate ID: 235885
emission angle derived using
- an ellipsoidal reference surface (deg): 89.999961
- plate model's surface and normal vector (deg): 97.681554
Limb point: 3
Radius (km): 9.046773
Planetocentric longitude (deg): -88.051726
Planetocentric latitude (deg): -59.997991
Plate ID: 17961
emission angle derived using
- an ellipsoidal reference surface (deg): 89.996966
- plate model's surface and normal vector (deg): 64.808794
Boundaries of visible regions on an arbitrary surface are often
complicated point sets: boundaries of mountains and craters, if
present, may contribute to the overall set. To make the limb
computation tractable, we simplify the problem by using a reference
ellipsoid for guidance. We compute a set of limb points on the
reference ellipsoid for the target body, then use those points to
define the latitudes and longitudes of limb points on the surface
defined by the specified triangular shape model. As such, the set
of limb points found by this routine is just an approximation.
For important details concerning this module's function, please
refer to the CSPICE routine limb_pl02.
MICE.REQ
DSK.REQ
PCK.REQ
SPK.REQ
TIME.REQ
-Mice Version 1.0.0, 25-JUL-2016, NJB, EDW (JPL)
find limb on a dsk type_2 model
find limb on a triangular plate_model
|


Lifting State Up
A component can have child components that need to share the same state. In order to make that work, we recommend raising the state up to the parent component.
To understand how to list state up, we are going to create a temperature calculator that determines whether water would boil or not. It will accept both Cesius and Fahrenheit, converting between them. So, here's are first function:
function BoilingVerdict(props) {
if (props.celsius >= 100) {
return
The water will boil.

}
return
The water will not boil.

}
The functional component BoilingVerdict
will print out whether the temperature would cause water to boil or not. Next we need to create the Calculator
component. It will keep track of temperature through this.state.temperature
. It will also render the BoilingVerdict
component based on the current temperature:
See the Pen Composi Tuts - Lifting State-1 by Robert Biggs (@rbiggs) on CodePen.
A quick FYI for the Americans viewing this. 0° Cesius is the freezing point and 100° Cesius is the boiling point. So, any value less than 100 should show: 'The water would not boil', and any value of 100 or higher should show: 'The water will boil'.
A Second Temperature Input
Now we want to add a second input for Fahrenheit. And we want them both synched, so that a change in the value of one will update the value of the other. In our previous component we had it own state. Now that we are going to have two components this gets complicated. We would wind up with race conditions over whose state wins out when changes are made. To resolve this we make both of them stateless and move the state up to their parent component.
In order for the two inputs to show the correct values, we'll use a funcional component to create them. This is very basic, both will receiver their data as props:
const TemperatureInput = (props) => (
<fieldset>
<legend>Enter temperature in {scaleNames[props.scale]}:</legend>
<input id={props.scale} value={props.temperature} />
</fieldset>
)
We can use this functional input as a custom tag in our Calculator
component. We will also need to give our parent component two methods to convert between Cesius and Fahrenheit: toCelsius
and toFahrenheit
. We'll also add a handleEvent
method to manage the user input on the two form inputs. With all this in mind, here is our updated temperature calculator:
See the Pen Composi Tuts - Lifting State-2 by Robert Biggs (@rbiggs) on CodePen.
Now we have a calculator with two child components sharing the state of their parent. The parent component handles the state of the child components. The child inputs get their values through props. Since the child inputs are dumb, not knowing anything about their parent, we could more easily reuse them elsewhere.
We could have written the TemperatureInput
component in such a way that each input had state and used event emitters to inform the parent of their change, which would then have to notify the other child. As you can see from that description, that would be convoluted. Raising the state of the child inputs to their parent component relieves this unnecessary complexity and results in an easier to understand and maintain component.
Data Should Flow Down
Always keep in mind that with components, data should always flow down to their children. The only time you might need some type of event emitter would be where you had two disparate class components that needed to communicate with each other. It can happen. Any pubsub solution from NPM would be sufficient in such a case.


Hello! I'm Ethan, a full stack developer based in Southern California.
I'm experienced with JavaScript ES5/ES6+, CSS3, HTML5, React, Node, and PostgreSQL. I use tools such as HTTPie, Express, NPM, Bootstrap, and Webpack to supplement my programming languages, and to design dynamic, responsive applications. I have built Full stack applications as part of a team using AGILE principles, and on my own using my own designs and ideas.
I discovered my passion for programming by accident, I was curious and bought a book on a whim, through that journey I found that programming combines my love of computers, design, and creation, and that I can build applications that make a difference.


Jekyll provides built-in support for Sass
and can work with CoffeeScript via a Ruby gem.
In order to use them, you must first create a file with the proper extension name
(one of .sass
, .scss
, or .coffee
)
and start the file with two lines of triple dashes, like this:
--- --- // start content .my-definition font-size: 1.2em
Jekyll treats these files the same as a regular page,
in that the output file will be placed in the same directory that it came from.
For instance, if you have a file named css/styles.scss
in your site's source folder,
Jekyll will process it and put it in your site's destination folder under css/styles.css
.
Jekyll allows you to customize your Sass conversion in certain ways.
Place all your partials in your sass_dir
, which defaults to <source>/_sass
.
Place your main SCSS or Sass files in the place you want them to be in the output file, such as <source>/css
.
For an example, take a look at this example site using Sass support in Jekyll.
If you are using Sass @import
statements,
you'll need to ensure that your sass_dir
is set to the base directory that contains your Sass files:
sass: sass_dir: _sass
The Sass converter will default the sass_dir
configuration option to _sass
.
You may also specify the output style with the style
option in your _config.yml
file:
sass: style: compressed
These are passed to Sass, so any output style options Sass supports are valid here, too.
To enable Coffeescript in Jekyll 3.0 and up you must
jekyll-coffeescript
gem_config.yml
is up-to-date and includes the following:plugins: - jekyll-coffeescript


Welcome to Coffeelike
This is Coffeelike, a two column CSS template by FreeCSSTemplates.org with photos from PDPhoto. It's released (for free) under the Creative Commons Attribution 3.0 license, so feel free to use it for any personal or commercial work, just keep our footer credit links intact. Hit up our website for more awesomely cool free templates, and follow us on Twitter (@freecsstemplate) for updates, announcements, and other mildly interesting ramblings.
Primis dolor fringilla porta
- Quis faucibus mauris quis consectetur lobortis parturient sit turpis scelerisque neque aliquet.
- Lobortis malesuada penatibus porta varius ligula blandit sit dolor mattis morbi ullamcorper posuere tempus.
- Diam nunc turpis placerat imperdiet ac cras ac sociis aliquam sed lacinia augue suspendisse.
Magnis felis
Vulputate magna nibh augue. Rutrum nibh sodales porta etiam.


It is recommended to avoid floating point literals ending with a decimal point ('.'). This prevents confusion with method call syntax.


How to build a simple sturdy workbenchThis article also available in Spanish French German and Italian (you too can help with translations)I had previously posted an article about building this style of workbench, but I recently built another one like this for my friend Roland, this time shooting video of the build. And so I figured I might as well do a more detailed write-up on how to build it using pictures from the video. To demonstrate that you don't need a workshop full of tools to build one of these, I'm building this one with just a WorkMate, a cheap circular saw, a hand drill, bar clamps, a square, and a chisel. Getting clean crosscuts is really important. So I made a simple T-square cross-cutting guide by gluing a scrap of plywood across another scrap of wood. Clamping this to the 2x4 gives a good edge to guide the saw. The guide ends exactly where the saw cuts, so it's just a matter of positioning the edge of the guide against where the cut is to be made. With the guide clamped to the 2x4, I can use both hands to guide the saw.
I'm joining the legs to cross-pieces with dowels. Here I'm using some scraps of wood to clamp the leg against the end of the cross-piece. I'm also adding some screws to the joint (I didn't do this on my last build, but screws make the build much easier). The screws really help to hold the joint together while drilling the dowel holes. I pre-drill a shank hole, 5/32" in size for the #7 drywall screw. I set the drill bit deep into the chuck so that my drill only drills through the first 2x4. After pre-drilling, I add two 3" long drywall screws. With the screws in place, I drill two 5/8" (16 mm) holes for the dowels. Because I'm drilling through both pieces at the same time, the holes will line up even if I drill the holes a little crooked. To get more depth with the drill bit, I only partially inserted it into the chuck. Before gluing in the dowel, I took the joint apart again and added glue to the flat joint surface. I'm not sure if this will help much, but it certainly can't hurt! I used a thin stick of wood to spread glue all over the inside of the hole and to the outside of the dowel. Then the dowels are inserted in the holes. I had a tight fit, so I had to drive the dowels in with a hammer! Two cross pieces attached to one leg, and the other leg already drilled. Here I just took the joint apart again to put glue on the inside surfaces before putting it back together and inserting the dowels. Excess glue squeezeout can be messy. It's best to rub sawdust onto the squeezed out glue. Sawdust absorbs the excess glue and prevents it from getting smeared everywhere. A chisel is good to scrape the glue soaked sawdust back off, and to flush trim the dowels if you need to. The doweling is the hardest part of the build. If you aren't up for it, I'd recommend using four or six drywall screws, 3" or 3.5" long instead of two screws and two dowels. Drill a 5/32" shank hole for the screw, and a 3/32" pilot hole in the end grain, just to reduce the chance of splitting the wood with that many screws. With the leg frames built, checking how it all goes together. Next I need to cut some dadoes into the long rails. These dadoes aren't strictly necessary, but make for a more secure joint with the legs. I set my circular saw to cut about one third into the rails. Two lines mark where the dado needs to be cut. I set my cutting guide back from the first line by the thickness of the blade, as I want to cut on the other side of the first line. I make a cut on either line with my cutting gauge, followed by a series of free-hand cuts in between. I then use a hammer to chip out most of the wood between the cuts...
... then clean up the bottom with a chisel. A sharp chisel makes this much easier. I also cut the lower corners of these rails at a 45-degree angle, strictly for cosmetic reasons. I marked that with a square, but cut it freehand. To make it easier to attach the workbench top, I'm gluing some 1.5x1.5x8" blocks of wood to the rails. I ripped these from a scrap of 2x4. You could also use pocket holes to attach the table top, but I don't have a pocket hole jig, so adding blocks was easier. Next, pre-drilling the screw holes for attaching the rails. I'm drilling these with a 5/32" drill. Then screwing on the rails. Much easier to do with the workbench lying on its side! It's been suggested that part of the legs should be cut away as well to form a shoulder to help hold up the rails. But this would complicate the build and weaken the dowel joint by cutting away part of it. I find the screws hold up the vertical load just fine. After that, screwing in the workbench top, from the bottom. The workbench top is an old wooden door - one from the 1950s, when they still used 1/4" plywood for the sides of it. It's quite heavy, solid enough to bolt a vise to. Modern inside doors are too flimsy to use as table tops, but new solid core doors make even better workbench tops. The last time I built one of these, I just screwed the door on from the top, but my friend has some plywood he wants to put on top of the door, so I figured it's better to screw the door on from below. Workbench dropped off at my friend Roland's.  I'm sure glad I decided to build it in my shop and then deliver it.
See also:
Quickie workbench
with the pantorouter
Mattias Karlsson's workbench project
Kevin's knock-down
workbench Back to my Woodworking website. |


UIJS is a simple and lightweight solution for routing pages in single page
applications.
It integrates with jQuery and makes page transitions a breeze. It depends on hashes instead of real paths thus we can easily isolate the client and server.
This is a lazy approach. I made it because I didn't felt like
using Vue or Angular for a simple app.
The 6 step implementation
- Link ui.js file to page
- Initialize or fetch an object 'Path' which consists of route & div id in pairs (to bind a div to a route)
- Add 'ui' class to all divs representing a page
- Add 'display: none' property to ui class in css
- Use 'uNav(route)' function to switch pages with user events
- Create a div with id 'e' for 404s
Now go ahead ... test / play / integrate
PS. You need to have jQuery linked
This is a sample page which has no purpose!
Note this page loads by default with the url
Click Me
That's what this is all about!
Also try adding a random string after #


Pasta Navy Style
This is one of the three pasta dishes that I usually cook. It’s a Russian pasta
recipe that is fast and easy to make and is quite tasty.
Ingredients
Here are the ingredients for about two hearty adult portions:
- 250g pasta. Usually I prefer to use fusilli or penne, but any short-cut pasta
should do.
- 300-400g ground beef
- 3-4 tomatoes
- 1 carrot
- ½ onion
- 2-3 garlic cloves
- Cumin
- Paprika
Directions
- Add olive oil to your frying pan, heat it to medium-high heat.
- Chop some onions and add them to the preheated pan.
- After a couple of minutes add the ground beef to the pan, salt it and mix it
a bit with the onions in the pan.
- When the meat is almost done, mince the garlic and add it together with the
cumin and paprika to the pan.
- Cook the pasta in a pot until its done al dente while the beef is being
cooked.
- Grate the tomatoes over the pan using a grater with small-sized slots, in
such a way that the tomato paste and juice falls right away from the grater
to the pan.
- Grate the carrot using a grater with medium-sized slots and add it to the
pan.
- Salt some more to taste, and add some black pepper to taste, mix.
- Cook it over medium/medium-low heat for about 10-15 minutes or until the
water and juices from the tomatoes have almost completely evaporated.
- Once (or if) the pasta and beef is already cooked, add the pasta to the pan
and cook for another couple of minutes.
- Serve hot and enjoy!
Originally published at https://www.yaroslavps.com/food/navy-style-pasta/
Contribution
Recipe tags:
russian
pasta
beef


{% set title = 'File Uploader' %} {% set filename = 'ui-file-uploader.html' %} {% extends 'layouts/master.html' %} {% block content %}
Javascript enhanced uploaders for easier file handling.
Using the basic file uploader up, upload here to see how
.basic-filepond
look.
Using the basic file uploader up, upload here to see how
.imgbb-filepond
-based basic file uploader look. You must use
name=image
or by FormData fieldName for your
input type=file
to upload in imgBB.
Using the basic table up, upload here to see how
.multiple-files-filepond
-based basic file uploader look. You can use
allowMultiple
or multiple
attribute too to implement multiple
upload.
Using the basic table up, upload here to see how
.with-validation-filepond
-based basic file uploader look. You can use
see here
or required (to make your input required), data-max-file-size (to limit your input file size),
data-max-files (to limit your uploaded files), etc (start with data-)
attribute
too to implement validation.
Using the basic table up, upload here to see how
.image-preview-filepond
-based basic file uploader look. This
preview for uploaded or dropped images.
Using the basic table up, upload here to see how
.image-exif-filepond
-based basic file uploader look. This
helps in correctly orienting photos taken on mobile devices.
Using the basic table up, upload here to see how
.image-crop-filepond
-based basic file uploader look. You can use
imageCropAspectRatio
or image-crop-aspect-ratio
to
set aspect ratio.
Using the basic table up, upload here to see how
.image-filter-filepond
-based basic file uploader look.
Using the basic table up, upload here to see how
.image-resize-filepond
-based basic file uploader look.


◆ Game()
- Precondition
- none
- Parameters
-
- Postcondition
- constructor
- Returns
- none
◆ ~Game()
- Precondition
- none
- Parameters
-
- Postcondition
- deconstructor
- Returns
- none
◆ easyTurn()
- Precondition
- none
- Parameters
-
- Postcondition
- AI's easy difficulty
- Returns
- none
◆ getCoordinateInput()
| void Game::getCoordinateInput |
( |
int *& |
coordinates | ) |
|
|
private |
- Precondition
- none
- Parameters
-
- Postcondition
- takes user input and returns threw reference coordinates
- Returns
- none
◆ hardTurn()
- Precondition
- none
- Parameters
-
- Postcondition
- AI's hard difficulty
- Returns
- none
◆ mediumTurn()
| void Game::mediumTurn |
( |
| ) |
|
|
private |
- Precondition
- none
- Parameters
-
- Postcondition
- AI's medium difficulty
- Returns
- none
◆ placeShips()
| void Game::placeShips |
( |
GameBoard & |
player, |
|
|
int |
numShips, |
|
|
int |
pNum |
|
) |
| |
|
private |
- Precondition
- user's input on how many ships they want
- Parameters
-
- Postcondition
- ships are placed onto a board
- Returns
- none
◆ placeShipsAI()
| void Game::placeShipsAI |
( |
GameBoard & |
AI, |
|
|
int |
numShips |
|
) |
| |
|
private |
- Precondition
- one player mode is picked
- Parameters
-
- Postcondition
- AI ship's are placed
- Returns
- none
◆ playAI()
- Precondition
- ships are placed for AI and player 1
- Parameters
-
- Postcondition
- function where single player game is played
- Returns
- none
◆ playGame()
- Precondition
- ships are placed for both players
- Parameters
-
- Postcondition
- function where two player game is played
- Returns
- none
◆ restrictIntInput()
| int Game::restrictIntInput |
( |
int |
option | ) |
|
|
private |
- Precondition
- none
- Parameters
-
- Postcondition
- points out invalid options
- Returns
- none
The documentation for this class was generated from the following files:
- C:/Users/mkapa/EECS448-Project1-FA19/Game.h
- C:/Users/mkapa/EECS448-Project1-FA19/Game.cpp


| ↑ Up |
Functions that create iterators.
iter(iterables.sum(list))
.
> chain(1..2,1..4).list() [1, 2, 1, 2, 3, 4]
> prod(["x","y"],[0,1]).list() [["x", 0], ["x", 1], ["y", 0], ["y", 1]]
a
.
The permuations are emitted in lexicographical order.
> permutations("abc").map(|t| t.join()).join("|") "abc|bac|bca|acb|cab|cba"
k
length
combinations of a
. The combinations are emitted
in lexicographical order.
x
over and over
again. If n
is given, the iterator will be exhausted
after n
calls.
a.step(m).list() == [a[0],a[m],a[2*m],...]
Functional programming.
fib = fix({},|f,n| 1 if n==1 or n==2 else f(n-1)+f(n-2)) fib = fix({1: 1, 2: 1}, |f,n| f(n-1)+f(n-2))
x
is done by x.value()
.
The expression is evaluated only once, the result then memoized for
subsequent calls.


Looking for: {{service.description}}
Paying: ${{service.wage}} lump sum
Upload your own resume in a pdf.


From v12.2 onwards, Please has cross-compilation support. This allows you to instruct it to build outputs for other architectures alongside the host architecture.
To target a different architecture, use the
--arch
flag when invoking plz. Architectures are
formed of a two-part tags in a similar format to Go's - i.e.
linux_amd64
etc. These are passed in as a single
flag but decomposed into separate OS and architecture parts for later
operations. You can request whatever architecture you want, but obviously the
build will not succeed unless you have tools that understand that
architecture.
The outputs from a cross-compiled build will be in a directory under plz-out
prefixed with the architecture - e.g.
plz-out/bin/linux_x86
,
plz-out/gen/darwin_amd64
etc.
Cross compilation is primarily achieved through global variables in the BUILD language. Build rules adjust their commands as necessary based on these values. When compiling a target for a different architecture, the BUILD file is re-parsed generating specialised rules for that architecture.
The CONFIG.ARCH
and
CONFIG.OS
properties will be set to the target
architecture. Similarly, when the rule builds, the
OS
and ARCH
environment
variables will also be set. The CONFIG.HOSTOS
and
CONFIG.HOSTARCH
contain the host machines
operating system and CPU architecture.
The distinction between tools
and other
dependencies of a target (e.g. src
or
deps
) is extremely important when
cross-compiling. Dependencies of a rule typically behave as you'd hope. All
dependencies except tools
will use the target architecture unless explicitly told not to via a
platform specific label e.g.
///linux_amd64//some/target
.
Tools, on the other hand, always use the host architecture since they are
executed on the host during the build. In some cases tools might need to
know the architecture they're targeting. To facilitate this, the target
architecture is set in CONFIG.TARGET_OS
and
CONFIG.TARGET_ARCH
.
The config file for any target
architecture is read (if present) and applied for targets compiling for that
architecture - e.g. .plzconfig_linux_x86
.
Typically you will need to create this file and modify the appropriate
settings i.e. compiler flags.
The various builtin languages have differing levels of support. Currently they are as follows:
Works for most cases; there is an example in the Please repo which tests a simple amd64 -> x86 compilation.
You will need to alter the config file to make this work - see the example for x86 for some examples of the settings to change. So far this has not been tested in anger on a more complex setup.
Works well across all platforms supported by Go. When using go_toolchain() to manage your go installation, cross compilation works out of the box.
Otherwise you must ensure the standard library is available for the target
architecture on the host machine via
GOOS="linux" GOARCH="386" go install -i std
.
Currently has very limited support. Of course it will work for pure Python, however, binary modules built locally need a similar approach to C.
Binary third-party modules downloaded via pip_library won't work since pip can't be instructed to use a different architecture. python_wheel works fine but requires something else to have built & hosted the .whl file.
This is not terribly relevant to Java since it effectively always targets
the same JVM architecture.
maven_jar
rules that specify native = True
will download
for the target architecture.
While not exactly related to this cross-compilation mechanism, there are also config options controlling the target, source and release level for Java.


Toggle navigation
{{ pageTitle }}
{{ grp.name }}
Bookmarks
Recently Added Bookmarks
Groups
Tags
About
Feedback
{{ sessionUser.screenName }}
Profile
Change Password
Log Out on All Devices
Log Out
×
Feedback
Subject:
{{option}}
Message:
×
Did You Know?


Subject: Your "{{campaign_title}}" event has been approved! {% load actionkit_tags %}
Congratulations! Your "{{campaign_title}}" event has been approved and is now open for signups!
You can start sharing your event at {% endfilter %} http://{% client_domain %}{{ event.public_url }} with potential attendees.
{% filter akid:user|number_links|cleanup_links %}To use your event tools, visit https://{% client_ssl_domain %}{{ signup.url }}
Thanks again!
You're receiving this message because you set up a "{{campaign_title}}" event. If you don't want to receive further emails about this event, you can cancel the event using the host tools linked above.