Android
Prerequisites
-
Binding created.
-
A configuration file added to the apps assets directory.
-
Core module imported.
Setup Keycloak
The following guide helps you to configure schema of the redirect url and web origin for a client in Keycloak. This is required to use the Auth SDK.
Procedure
-
Choose the schema of a redirect url.
It is recommended to use the package name of the Android app as the schema of the redirect url to avoid conflicts. -
Open Keycloak Administration Console by selecting route in OpenShift.
-
Open
Clients
from the menu. -
Open your Android client.
-
Add the schema to
Valid Redirect URIs
. -
Add
*
toWeb Origins
.
Initializing the SDK
AuthService
can be retrieved using the MobileCore#getInstance
method.
AuthService authService = MobileCore.getInstance().getService(AuthService.class);
Any subsequent getService
call will return the same instance of AuthService
.
Before the AuthService
can be used AuthService#init
must be invoked once in an app.
// Specify redirect URI. It is recommended to use the package name of your app.
AuthServiceConfiguration authServiceConfig = new AuthServiceConfiguration
.AuthConfigurationBuilder()
.withRedirectUri("org.aerogear.mobile.example:/callback")
.build();
// You only need to invoke this once every subsequent retrieval of the AuthService
// will retrieve the same instance.
authService.init(context, authServiceConfig);
Authentication Browser
The AuthService
can also be configured to whitelist or blacklist browsers that should or shouldn’t be used during authentication. During authentication the Auth SDK
redirects the user to an internet browser. A Keycloak login web page is loaded in this internet browser to allow users to authenticate.
Authentication Browser
is referring to that internet browser used during authentication. The Auth SDK
provides some Pre-defined Browsers that can be used to be whitelisted or blacklisted and there is also the option to use Custom Browsers.
The Auth SDK
can be configured to to use specific browsers and versions, this is know as whitelist
, or the Auth SDK
can be configured to permit specific browsers and versions, this is known as blacklist
. Once one or more internet browsers have been configured they can be configured to be blacklisted or whitelisted using Browser Configuration.
Pre-defined Browsers
There are some pre-defined browsers that can be be customised to be used as standalone or custom tab browsers and can target a specific version or version range. There are also default options available where no extra configuration is needed.
A pre-defined browser can be retrieved from AuthBrowsers
:
// a default Google Chrome browser. No extra configuration is neccessary.
AuthBrowser chromeBrowser = AuthBrowsers.CHROME_DEFAULT;
// a customisable Samsung browser where the custom tab mode has been set to `false` i.e.
// it should be used as a standalone browser and the version should be at least 6.
AuthBrowser samsungBrowser = AuthBrowsers.samsung(false, AuthBrowserVersionRange.atMost("6"));
For the full list of predefined browsers available see AuthBrowsers.java.
Custom Browsers
To use a custom browser an AuthBrowser object can be created:
AuthBrowser customBrowser = new AuthBrowser("custom.package.name", signatureSet, true, AuthBrowserVersionRange.ANY);
Browser Configuration
Once a browser or browsers have been configured, BrowserConfiguration
can be used to either blacklist or whitelist these browsers.
| It’s only possible to blacklist or whitelist a browser/browsers. It is not possible to both whitelist and blacklist a browser/browsers. If both are invoked the most previous browser configuration built will be used. |
// blacklist the default Mozilla Firefox browser i.e. any version of Mozilla firefox for use as a standalone browser will be permitted for authentication
BrowserConfiguration browserConfiguration = new BrowserConfiguration.BrowserConfigurationBuilder().blackList().browser(AuthBrowsers.FIREFOX_DEFAULT).build();
// whitelist a custom Google Chrome browser i.e. a Google Chrome browser for use as a standalone browser where the version range is between 45 and 55.
AuthBrowser customChrome = AuthBrowsers.chrome(false, AuthBrowserVersionRange.between("45", "55"));
BrowserConfiguration browserConfiguration = new BrowserConfiguration.BrowserConfigurationBuilder().whitelist().browser(customChrome).build();
// blacklist the two browsers
BrowserConfiguration browserConfiguration = new BrowserConfiguration.BrowserConfigurationBuilder().blacklist().browser(AuthBrowsers.FIREFOX_DEFAULT).browser(customChrome).build();
// add the two browsers to a Set and whitelist the set of browsers
AuthBrowser samsungCustomTab = AuthBrowsers.SAMSUNG_CUSTOM_TAB;
Set<Browser> browsers = new HashSet<>(Arrays.asList(samsungCustomTab, customChrome));
BrowserConfiguration browserConfiguration = new BrowserConfiguration.BrowserConfigurationBuilder().whiteList().browsers(browsers).build();
The AuthService
can be configured to use the browser configuration once its been instantiated:
// auth service configuration
AuthServiceConfiguration authServiceConfig = new AuthServiceConfiguration
.AuthConfigurationBuilder()
.withRedirectUri("org.aerogear.mobile.example:/callback")
.build();
// browser configuration
BrowserConfiguration browserConfiguration = new BrowserConfiguration.BrowserConfigurationBuilder()
.blackList()
.browser(AuthBrowsers.CHROME_CUSTOM_TAB)
.build();
authService.init(context, authServiceConfig, browserConfiguration);
Defining Custom Scopes
Optionally, scopes can be defined for the auth request using a space as the delimiter as per RFC-6749.
By default, the "openid"
scope is sent if no scopes are defined.
// default is 'openid' when not defined
.withScopes("openid offline_access")
If AuthService#init
is not invoked then an IllegalStateException
will be thrown when using the
service.
Retrieving the current user
To retrieve the current authenticated user the AuthService#currentUser
method can be invoked. This will be null
if there is no user authenticated. So it can be used to check whether to start the authentication flow or not.
// authService already initialized.
UserPrincipal currentUser = authService.currentUser();
if (currentUser != null) {
// User is authenticated, get the users username
String userName = currentUser.getUsername();
// Get the users first name
String firstName = currentUser.getFirstName();
// Get the users last name
String lastName = currentUser.getLastName();
// Get the users email address
String userEmail = currentUser.getEmail();
// Get the access token of the authenticated user
String accessToken = currentUser.getAccessToken();
// Get the identity token of the authenticated user
String identityToken = currentUser.getIdentityToken();
// Get the refresh token of the authenticated user
String refreshToken = currentUser.getRefreshToken();
} else {
// User is not authenticated, start authentication flow
}
Retrieving Custom User Attributes
A walkthrough has been provided in the Keycloak Custom User Attributes document to show how you can allow custom user attributes in Keycloak to be available in the Identity token.
You can then retrieve the custom attributes from the current user.
boolean booleanAttribute = currentUser.getCustomBooleanAttribute("booleanAttribute");
int intAttribute = currentUser.getCustomIntegerAttribute("intAttribute");
long longAttribute = currentUser.getCustomLongAttribute("longAttribute");
String stringAttribute = currentUser.getCustomStringAttribute("stringAttribute");
Authenticating
To start the authentication invoke the AuthService#login
method.
// authService already initialized.
AuthService authService = MobileCore.getInstance().getService(AuthService.class);
static int LOGIN_RESULT_CODE = 1;
// Build the options object and start the authentication flow.
// Provide an activity to handle the auth response.
DefaultAuthenticateOptions options =
new DefaultAuthenticateOptions(myActivity, LOGIN_RESULT_CODE);
Callback authCallback = new Callback<UserPrincipal>() {
@Override
public void onSuccess(UserPrincipal principal) {
// User authenticated in, continue on..
}
@Override
public void onError(Throwable error) {
// An error occurred during login.
}
};
authService.login(options, authCallback);
Once the browser returns to the app the result can be handled. In the activity provided to the
login
method override onActivityResult
. This handler should always invoke
AuthService#handleAuthResponse
, providing the Intent
. This will exchange the temporary tokens
returned from AuthService#login
for long-life tokens and will provide a UserPrincipal
which can
be used to access a users details. If this is not invoked you will not have access to the
UserPrincipal
.
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == LOGIN_RESULT_CODE) {
// The core will return the same instance of the auth service as before
AuthService authService = mobileCore.getInstance(AuthService.class);
authService.handleAuthResult(data);
}
}
The callback provided in AuthService#login
will be invoked.
Retrieving a users roles
Once a UserPrincipal
has been retrieved the roles of the user can be listed and checked. This can
be used to perform client side access control, such as hiding UI components related to actions the
user doesn’t have permissions to perform.
To list a users roles the UserPrincipal#getRoles
method can be invoked.
Roles are divided into two types. Resource roles which belong to the client the user has authenticated against, and Realm roles which belong to the realm the client is in.
To list a users realm roles the UserPrincipal#getRealmRoles
method can be invoked and
to list a users resource roles the UserPrincipal#getResourceRoles
can be invoked.
In order to check if a user has a specific role you can invoke the UserPrincipal#hasResourceRole
and UserPrincipal#hasRealmRole
methods and provide the role name to check for.
// authService already initialized.
AuthService authService = MobileCore.getInstance().getService(AuthService.class);
UserPrincipal currentUser = authService.currentUser();
boolean hasAdminPermissions = currentUser.hasRealmRole("user_admin");
if (hasAdminPermissions) {
// Show some component.
}
// Check if a user has a role from a specific resource named my_resource.
boolean isModerator = currentUser.hasResourceRole("my_resource", "user_moderator");
if (isModerator) {
// Enable some button.
}
Logging out
To logout, invoke the AuthService#logout
method. This accepts the UserPrincipal
that was
provided by AuthService#handleAuthResponse
and has a callback to determine if the logout to the Keycloak or OpenID Connect server was successful.
// authService already initialized.
AuthService authService = MobileCore.getInstance().getService(AuthService.class);
UserPrincipal currentUser = authService.currentUser();
authService.logout(currentUser, new Callback<UserPrincipal>() {
@Override
public void onSuccess() {
// User Logged Out Successfully and Local Auth Tokens were Deleted
}
@Override
public void onError(Throwable error) {
// An error occurred during logout
}
});
By default, the local tokens obtained during authentication are only deleted when the logout succeeded against the authentication server.
You can use the AuthService#deleteTokens
function to delete the local authentication tokens as part of a failed logout, or for other use cases.
Note: To perform backchannel or federated logouts, you must enable the Backchannel Logout option for the federated identity provider. More information is available in the Keycloak documentation under OIDC Identity Providers.
Single Sign-on
A walkthrough on how to setup Single Sign-on across Android Applications can be seen under the Single Sign-on Documentation.


Flexible client-side table sorting. Filter the table using the input field to the right side of the screen.
| Rank | First Name | Last Name | Age | Total | Discount | Date |
|---|---|---|---|---|---|---|
| 1 | Philip Aaron | Johnson Sr Esq | 25 | $5.95 | 22% | Jun 26, 2004 7:22 AM |
| 11 | Aaron | Hibert | 12 | $2.99 | 5% | Aug 21, 2009 12:21 PM |
| 12 | Brandon Clark | Henry Jr | 51 | $42.29 | 18% | Oct 13, 2000 1:15 PM |
| 111 | Peter | Parker | 28 | $9.99 | 20% | Jul 6, 2006 8:14 AM |
| 21 | John | Hood | 33 | $19.99 | 25% | Dec 10, 2002 5:14 AM |
| 013 | Clark | Kent Sr. | 18 | $15.89 | 44% | Jan 12, 2003 11:14 AM |
| 005 | Bruce | Almighty Esq | 45 | $153.19 | 44% | Jan 18, 2021 9:12 AM |
| 10 | Alex | Dumass | 13 | $5.29 | 4% | Jan 8, 2012 5:11 PM |
| 16 | Jim | Franco | 24 | $14.19 | 14% | Jan 14, 2004 11:23 AM |
| 166 | Bruce Lee | Evans | 22 | $13.19 | 11% | Jan 18, 2007 9:12 AM |
| 100 | Brenda Lee | McMasters | 18 | $55.20 | 15% | Feb 12, 2010 7:23 PM |
| 55 | Dennis | Bronson | 65 | $123.00 | 32% | Jan 20, 2001 1:12 PM |
| 9 | Martha | delFuego | 25 | $22.09 | 17% | Jun 11, 2011 10:55 AM |


We'll need a few details about your pet. You may add a bio with important information to help us take care of your dog. Add a photo link from your social media if you like.


{% extends "base.html" %} {% load i18n %} {% block content %}
{% blocktrans %}RIn offers to you a scientific, application or capital collaboration on its projects, lease of sources and final products.{% endblocktrans %}
{% trans 'chci zjistit více' %}


←
Home
About
RSS
Brian Schrader
TIL that you can design custom telecasters... (designed, not ordered) http://bit.ly/1WuxSAF
Why is there no standard way of sharing music playlists? And if there is, why doesn't iTunes support it?
Well, I skimmed that paper and looked at the graphs. That's about all I could understand. :P
My reading for today: Generalized methods and solvers for noise removal from piecewise constant signals. We'll see how this goes.
A good morning so far. http://bit.ly/1R6435L
Everyone needs this Giphy Alfred workflow. http://bit.ly/1Xt1K0D
Google's like, "Platform specific interface guidelines? lolwut?" http://bit.ly/1QTq2iA
That's probably the 10th time I've posted that. It's not funny to most people, but it's funny to me.
Thanks @overcast! I've wanted a dark mode forever (looks great too) and file upload is something I can't wait to use.
A universal install script. http://xkcd.com/1654/
🎶Mocking all the things🎶
Dat rain doe
🌧🌧🌧🌧🌙🌧🌧🌧🌧
but seriously I don't think you realize how much time you actually spend just browsing (the modern equivalent of flipping channels)
I recommend filtering HN through to an RSS feed. You'll spend less time searching and more time reading things that are important to you.
After adding automatic filtering to Hacker News, I've realized how few of the posts I actually want to read. It's not a bad thing.
I'm exahusted. Want sleep.
Project meeting time! 🕖🎉🍹
It's a stupidly beautiful day.
My coffee was cold. I warmed it up. Now it is cold again. #cantwin #failwhale #suckstobeme #tuesdays
←
Newer Posts
Older Posts
→


Elf: A Christmas Spectacular on the arena stage this Christmas
It’s a must-see stage event this Christmas.
by Nicola JaquesBuddy the Elf is back for a Christmas Spectacular.
Blackpool actor and singer Tam Ryan returns as leading role in upcoming Elf: A Christmas Spectacular, which is showing at Liverpool’s M&S Bank Arena on December, 7 and 8.
The musical, boasting a star-studded cast including Coronation Street’s Kym Marsh, 43, and former EastEnders hero Shaun Williamson, 53, is a stage adaptation of the hit 2003 Hollywood movie Elf, starring funnyman Will Ferrell.
Former-Emmerdale actor Tam, 43 who now lives in Blackpool, will play the titular character of Buddy the Elf, who leaves the comfort of the North Pole to go in search of his real-life dad.
The father-of-two said he was excited to be pulling back on his Elf shoes, those made famous by Ferrell in the much-loved Christmas film.
He said: “This is a kind of a reincarnation of Elf - we’ve taken a bit of the film and a bit of the musical and turned it into an arena show.
"In the past it has been done in a very Broadway style, then in a very West End style, so I’ve tried to bring it closer to the film, as the director wanted me to.
“So when one of these American guys saw our production last year and said that he thought Will Ferrell would have appreciated my interpretation of the character, I thought that was great.
“I’m playing Buddy and he gets a bit more license than anyone else.
"There are times when I’m out among the audience, which is one of my favourite bits of the show. It’s a voyage into the unknown.
“The beauty of the character is that everything is new to him, he doesn’t know what popcorn or beer are.
Those bits can’t be scripted and shouldn’t be scripted. It has to be what you find - and those are some of the best moments.”
With three stages, a flying sleigh, an audience snowball fight, amazing CGI-animated backdrops with giant TV screens, Elf is coming to Liverpool in on December 7 and 8.
Tickets from £37.50.
Visit https://buddytheelf.co.uk/elfthemusical/


{% extends 'base.html' %} {% load static %} {% block main %}
{{ message }}
Try Also these awesome products
{{ product.description | safe }}
{{ review.name }}
{{ review.published }}
{{ review.comment | safe }}


| Opcode/Instruction | Op/En | 64/32 bit Mode Support | CPUID Feature Flag | Description |
|---|---|---|---|---|
|
0F 38 03 /r1 PHADDSW mm1, mm2/m64 |
RM | V/V | SSSE3 | Add 16-bit signed integers horizontally, pack saturated integers to mm1. |
|
66 0F 38 03 /r PHADDSW xmm1, xmm2/m128 |
RM | V/V | SSSE3 | Add 16-bit signed integers horizontally, pack saturated integers to xmm1. |
|
VEX.NDS.128.66.0F38.WIG 03 /r VPHADDSW xmm1, xmm2, xmm3/m128 |
RVM | V/V | AVX | Add 16-bit signed integers horizontally, pack saturated integers to xmm1. |
|
VEX.NDS.256.66.0F38.WIG 03 /r VPHADDSW ymm1, ymm2, ymm3/m256 |
RVM | V/V | AVX2 | Add 16-bit signed integers horizontally, pack saturated integers to ymm1. |
NOTES:
1. See note in Section 2.4, “AVX and SSE Instruction Exception Specification” in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 2A and Section 22.25.3, “Exception Conditions of Legacy SIMD Instructions Operating on MMX Registers” in the Intel® 64 and IA-32 Architectures Software Developer’s Manual, Volume 3A.
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| RM | ModRM:reg (r, w) | ModRM:r/m (r) | NA | NA |
| RVM | ModRM:reg (w) | VEX.vvvv (r) | ModRM:r/m (r) | NA |
(V)PHADDSW adds two adjacent signed 16-bit integers horizontally from the source and destination operands and saturates the signed results; packs the signed, saturated 16-bit results to the destination operand (first operand) When the source operand is a 128-bit memory operand, the operand must be aligned on a 16-byte boundary or a general-protection exception (#GP) will be generated.
Legacy SSE version: Both operands can be MMX registers. The second source operand can be an MMX register or a 64-bit memory location.
128-bit Legacy SSE version: The first source and destination operands are XMM registers. The second source operand is an XMM register or a 128-bit memory location. Bits (VLMAX-1:128) of the corresponding YMM destina-tion register remain unchanged.
In 64-bit mode, use the REX prefix to access additional registers.
VEX.128 encoded version: The first source and destination operands are XMM registers. The second source operand is an XMM register or a 128-bit memory location. Bits (VLMAX-1:128) of the destination YMM register are zeroed.
VEX.256 encoded version: The first source and destination operands are YMM registers. The second source operand can be an YMM register or a 256-bit memory location.
Note: VEX.L must be 0, otherwise the instruction will #UD.
PHADDSW (with 64-bit operands)
mm1[15-0] = SaturateToSignedWord((mm1[31-16] + mm1[15-0]); mm1[31-16] = SaturateToSignedWord(mm1[63-48] + mm1[47-32]); mm1[47-32] = SaturateToSignedWord(mm2/m64[31-16] + mm2/m64[15-0]); mm1[63-48] = SaturateToSignedWord(mm2/m64[63-48] + mm2/m64[47-32]);
PHADDSW (with 128-bit operands)
xmm1[15-0]= SaturateToSignedWord(xmm1[31-16] + xmm1[15-0]); xmm1[31-16] = SaturateToSignedWord(xmm1[63-48] + xmm1[47-32]); xmm1[47-32] = SaturateToSignedWord(xmm1[95-80] + xmm1[79-64]); xmm1[63-48] = SaturateToSignedWord(xmm1[127-112] + xmm1[111-96]); xmm1[79-64] = SaturateToSignedWord(xmm2/m128[31-16] + xmm2/m128[15-0]); xmm1[95-80] = SaturateToSignedWord(xmm2/m128[63-48] + xmm2/m128[47-32]); xmm1[111-96] = SaturateToSignedWord(xmm2/m128[95-80] + xmm2/m128[79-64]); xmm1[127-112] = SaturateToSignedWord(xmm2/m128[127-112] + xmm2/m128[111-96]);
VPHADDSW (VEX.128 encoded version)
DEST[15:0]= SaturateToSignedWord(SRC1[31:16] + SRC1[15:0]) DEST[31:16] = SaturateToSignedWord(SRC1[63:48] + SRC1[47:32]) DEST[47:32] = SaturateToSignedWord(SRC1[95:80] + SRC1[79:64]) DEST[63:48] = SaturateToSignedWord(SRC1[127:112] + SRC1[111:96]) DEST[79:64] = SaturateToSignedWord(SRC2[31:16] + SRC2[15:0]) DEST[95:80] = SaturateToSignedWord(SRC2[63:48] + SRC2[47:32]) DEST[111:96] = SaturateToSignedWord(SRC2[95:80] + SRC2[79:64]) DEST[127:112] = SaturateToSignedWord(SRC2[127:112] + SRC2[111:96]) DEST[VLMAX-1:128] (cid:197) 0
VPHADDSW (VEX.256 encoded version)
DEST[15:0]= SaturateToSignedWord(SRC1[31:16] + SRC1[15:0]) DEST[31:16] = SaturateToSignedWord(SRC1[63:48] + SRC1[47:32]) DEST[47:32] = SaturateToSignedWord(SRC1[95:80] + SRC1[79:64]) DEST[63:48] = SaturateToSignedWord(SRC1[127:112] + SRC1[111:96]) DEST[79:64] = SaturateToSignedWord(SRC2[31:16] + SRC2[15:0]) DEST[95:80] = SaturateToSignedWord(SRC2[63:48] + SRC2[47:32]) DEST[111:96] = SaturateToSignedWord(SRC2[95:80] + SRC2[79:64]) DEST[127:112] = SaturateToSignedWord(SRC2[127:112] + SRC2[111:96]) DEST[143:128]= SaturateToSignedWord(SRC1[159:144] + SRC1[143:128]) DEST[159:144] = SaturateToSignedWord(SRC1[191:176] + SRC1[175:160]) DEST[175:160] = SaturateToSignedWord( SRC1[223:208] + SRC1[207:192]) DEST[191:176] = SaturateToSignedWord(SRC1[255:240] + SRC1[239:224]) DEST[207:192] = SaturateToSignedWord(SRC2[127:112] + SRC2[143:128]) DEST[223:208] = SaturateToSignedWord(SRC2[159:144] + SRC2[175:160]) DEST[239:224] = SaturateToSignedWord(SRC2[191-160] + SRC2[159-128]) DEST[255:240] = SaturateToSignedWord(SRC2[255:240] + SRC2[239:224])
PHADDSW:
__m64 _mm_hadds_pi16 (__m64 a, __m64 b)
(V)PHADDSW:
__m128i _mm_hadds_epi16 (__m128i a, __m128i b)
VPHADDSW:
__m256i _mm256_hadds_epi16 (__m256i a, __m256i b)
None.
See Exceptions Type 4; additionally
| #UD | If VEX.L = 1. |


Nested recognizers are possible with some threshold and with use of requireFailure().
requireFailure()


Hi, I'm Charlie!
I'm currently a Software Engineering Technology student at
Conestoga College in
Waterloo, Ontario.
I have experience developing in
C,
C++ and
Python, as
well as web-development experience in
HTML,
CSS and
Javascript.
I founded a programming club at Conestoga for students to
brainstorm, work on independent and group projects, network
and progress their programming skills. Check us out here!
I'm passionate about the tech community and always looking
to collaborate on exciting new projects with people in the Waterloo region.
This Summer, I'll be interning at
Mappedin as a Software
Tester.
Feel free to contact me at<EMAIL_ADDRESS>or at any of my social media links below


Before Change
similar = [
["What is the meaning of life?", "What does life mean?"],
["Why did the chicken cross the road", "Why did the chicken walk across the road"],
["What was the cause of the economic crisis?", "What caused the economic crash?"],
["Whats the name of the current Queen of England", "What is the current Queen of England"s name?"],
["Is fish good for your brain?", "Ive heard fish is good for your brain, is this true?"],
After Change
model = Comparison(**self.default_config(n_epochs=3))
// fake dataset generation
animals = ["dog", "cat", "horse", "cow", "pig", "sheep", "goat", "chicken", "guinea pig", "donkey", "turkey", "duck", "camel", "goose", "llama", "rabbit", "fox"]
numbers = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen"]
n_per = 50
similar = []
different = []
for dataset in [animals, numbers]:
for i in range(n_per // 2):
similar.append([random.choice(dataset), random.choice(dataset)])
for i in range(n_per):
different.append([random.choice(animals), random.choice(numbers)])
targets = np.asarray(["similar"] * len(similar) + ["different"] * len(different))
data = similar + different


Jack Baxter, William Conti, Xuyang Li, Ken Ma
Service-Learning Course Project as part of DS 4200: Information Presentation and Visualization, taught by Prof. Dylan Cashman, Data Visualization @ Khoury, Northeastern University.
The Sustainable Business Network (SBN) is a non profit organization aiming to create a community capable of sustainable local production and demand. This visualization will showcase the current members of the network, including types of members and a geographic representation of member distribution. It will assist in connecting not only local food buyers and vendors, but also members in fields such as financial services or energy and utilities within SBN.
This page will assist SBN in informing potentially interested people and help them learn about the members of SBN. As a local business network, SBN provides venues for a complex group of local businesses, ranging from commercial services to clean energy. When browsing through the visualizations we present, the user would be able to examine what kind of business are there, as well as where are they located if they have a physical location. They could also retrieve contact information of the business, such as a phone number or a directory to their websites.
Interactive Visualization
Embedded MP4 demo video using the HTML5 <video> tag:
Final visualization screenshots (PNG images), design justifications, UI walk-through, and linked presentation slides.
The treemap serves as a demonstration of categories of services available from members of SBN. A user could click a specific area of interest to show businesses from that category, such as members involved within the legal services industry; the main map will then filter to show only businesses of that type, and the table will be filtered to show only this category of businesses.
The geographical map of massachusets will allow the user to see the location of a vendor, if it has one. The map used is a map of MA centered around Greater Boston Area, since this is where the majority of SBN's members located.
Initially, location of all SBN members will be presented on the map. If the user select a category from the treemap, the locations where a vendor of that type is located in will be highlighted. If rows of the table is selected, location of those vendors will also be highlighted. This map will provide the user an impression of where the members of SBN are located.
The scrollable table shows a detailed collection of all information for a vendor, including the specific product or service, the address and the zip code, the phone number as well as the website. The table will serve as a directory for users to visit or contact the vendor of their greatest interest. The user could also select rows of table in order to view the location of the vendors on the map.
As the user click on a category (Light blue - Food Product for this case), areas with this category will be highlighted on the map, table will also be filtered to all vendors of this category.
If the user click on the map (the circled area), the table will be filtered and show members located at that area. The categories of members will also be hightlighted on the treemap.
When the user select rows from the table, the locations of members selected will be highlighted on the map. This will allow the user to quickly get an impression of the members' geographical information.
The above visualizations allows the users to achieve several domain tasks, such as identifying informations of a member providing certain type of service; it also allows the potential members of the SBN to examine the current network presented, both the geographical connection as well as the categorical diversity. It could also provide the SBN with a platform to showcase the members within the network. We employed ample amount of multi-directioned brushing and linking, allowing the users to interact with the visualization, carry out searches based on their needs.
For future work, the interaction could be enhanced. For instance, it would be helpful if the user could zoom into a specific area of MA. With a dynamic geographic map, the user could avoid certain obstacles, such as the location of the vendor is sometimes too small and might be hard to see from the bigger map. Furthermore, the map could be more specific, providing more detailed representation down to street address or present the density of members in an area with chromatic color.


GitHub profile for
GitHub Repository for (Project Name | Description):
Your search resulted in an error:


††††††††††† There are two major classes of MHC molecules, both of which consist of an a and a b chain, but from different sources.† MHC class I molecules (MHC I) consist of one membrane-spanning a chain (heavy chain) produced by MHC genes, and one b chain (light chain or b2-microglobulin) produced by the b2-microglobulin gene.† MHC class II molecules (MHC II) consist of two membrane-spanning chains, a and b, of similar size and both produced by MHC genes.† In each case, the MHC molecule has a groove that binds a peptide, which it can then present at the cell surface to a T cell to elicit an immune response, because T cells only recognise antigens as complexes with MHC molecules.† The two classes of MHC proteins differ not only in their structure, but more importantly in their functional roles within the immune system: †the two types of MHC molecules are specialised to present different types of antigens, thereby eliciting different responses.
††††††††††† MHC I glycoproteins are present on almost every cell in the body, acting to present endogenous antigens that originate from the cytoplasm.† These antigens include not only self-proteins, but also foreign proteins produced within the cell, such as viral proteins that take over the cellís machinery in order to replicate the virus. †When these proteins become degraded, the peptide fragments can be transported to the endoplasmic reticulum, where they can bind to MHC I proteins, before being transported via the Golgi apparatus to the cell surface.† Once at the cell surface, the membrane-bound MHC I protein displays the antigen for recognition by special immune cells known as cytotoxic T cell lymphocytes.† MHC I proteins work to present the types of proteins being synthesised within a cell, which can then be monitored by killer T cells as part of a surveillance system that identifies and destroys any cell with over-abundant or unfamiliar peptide antigens, such as malignant cells or those harbouring viruses.
††††††††††† MHC II glycoproteins are only present on specialised antigen-presenting immune cells, including macrophages that engulf foreign particles such as bacteria, dendritic cells that present antigen to T cells, and B cells that produce antibodies.† MHC II proteins present exogenous antigens that originate extracellularly from foreign bodies such as bacteria.† Upon encountering a pathogenic organism, proteins from the pathogen can be degraded into peptide fragments by the antigen-presenting cell, which then sequesters these fragments into the endosome so they can bind to MHC II proteins, before being transported to the cell surface.† Once at the cell surface, the membrane-bound MHC II protein displays the antigen for recognition by a different type of T cell, namely the helper T cell lymphocyte.† These helper T cells are activated upon binding to macrophage or dendritic cell MHC II-antigen, causing the release of lymphokines that attract other cells to the area of infection in an attempt to confine and destroy the antigenic material.† In addition, the binding of helper T cells to B cell MHC II-antigen stimulates the development of a clone of antibody-producing cells against the antigenic material.
|
MHC class I |
MHC class II |
|
Comprised of an MHC-encoded a chain and a b2-microglobulin chain |
Comprised of MHC-encoded a and b chains |
|
Present
on most cells |
Present
only on antigen-presenting cells |
|
Bind
endogenous antigens synthesized in a cell |
Binds exogenous
antigens |
|
Present antigen to cytotoxic T cell lymphocytes |
Present antigen to helper T cell lymphocytes |
|
Bind CD8 adhesion molecules on cytotoxic T cells |
Bind CD4 adhesion molecules on helper T cells |
|
Presence of foreign or over-abundant antigens targets cell for destruction |
Presence of foreign antigens induces antibody production, and attracts immune cells to area of infection |


RUGRATS IN PARIS A film review by James Brundage Copyright 2000 filmcritic.com filmcritic.com
Well, the Rugrats are back, and, as usual, they're way too sophisticated for their audience. The Simpsons of the Nickelodeon Network has meandered its way back onto the big screen, and this time they are hitting the streets of Paris with more Freudian slips than a sexually-charged first date.
To start with, Grandpa Lou has gotten remarried (leading into, by the way, an excellent parody of The Godfather in the first scene) and all Chuckie wants is a mommy. Meanwhile, Stu Pickles gets a call from Paris demanding that he come to fix a giant mechanical Reptar (a wonderful running Godzilla/Pokemon spoof gag from the series) which he designed.
After discovering the mommy button on an airplane (the flight attendant button), Chuckie decides that Paris is the perfect place to find a new mommy. The group proceeds to EuroReptarLand, where we discover that one Coco LaBouche (Susan Sarandon) needs to become a mother so she can move ahead in the Japanese conglomerate for which she works (oh, all the feminist implications one can see in this). Manipulative as Coco is, she decides to romance Chuckie's dad via her secretary Kira's knowledge of childrearing.
>From here on in the plot flows predictably, and the movie inserts its share of both lowbrow puns and intelligent humor throughout the entire film, making for a satisfactory viewing experience... a kid's movie the rest of us can stand (or even enjoy).
Of course Rugrats in Paris is hardly exemplary. It lacks the witty parodies of the first Rugrats film, and goes for too many fart-and-diaper jokes that are strictly kids-only. The show would better serve itself to go completely the route of The Simpsons and dropping all pretense of being kiddie fare, instead using its writers' satiric wit for all it's worth. But, as the Rugrats franchise will be raking in quite a few pretty pennies, don't expect anything like that to happen anytime soon.

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Your Content
+ HTML: Structure
+ CSS: Presentation
= Your Website
A website is a way to present your content to the world, using HTML and CSS to present that content & make it look good.
Photo credit: Nic's events cc
Photo credit: pumpkincat210 cc
ID - Should only apply to one element on a webpage, i.e., you might have an id of banner
on your webpage's banner.
The #
is how you find ids in CSS.
Class - Lots of elements can have the same class, i.e., There can be many elements with a warning
class on one webpage.
The .
is how you find classes in CSS.
HTML elements "nest" inside one another
Oftentimes, people think of HTML as something flat -- a bunch of text with tags in the middle.
<!DOCTYPE html>

<title>Test Page</title>

My Page

Hello World!

However, it is something much more than that. Any HTML document is a tree structure defined by the DOM (Document Object Model).
Your browser automatically loads the content of a webpage into a Document
object which serves as the entry point into a web page's content.
Using the document
you can:
Photo credit: Jeffery Beall cc
You can find nodes by id
using the method:
document.getElementById(id);
For example, to find:

We would use:
var imgKitten = document.getElementById('kittenPic');
You can also get HTML elements by their tag
using this method:
document.getElementsByTagName(tagName);
To find:

Daisy

Tulip

We would use:
var listItems = document.getElementsByTagName('li');
for (var i = 0; i < listItems.length; i++) {
var listItem = listItems[i];
}
In newer browsers, you can use methods getElementsByClassName
, querySelector
, and querySelectorAll
.
Available in IE9+, FF3.6+, Chrome 17+, Safari 5+:
document.getElementsByClassName(className);
Available in IE8+, FF3.6+, Chrome 17+, Safari 5+:
document.querySelector(cssQuery);
document.querySelectorAll(cssQuery);
Any method that starts with getElement
will return a single node.
document.getElementById('uniqueID'); // returns a single node
Any method that starts with getElements
will return an array of nodes. To modify a single node, you will need to use bracket notation to get the correct one.
document.getElementsByTagName('p'); // returns multiple nodes
var specificParagraph = document.getElementsByTagName('p')[2];
Photo credit: Darryl Kenyon cc
You can access and change attributes of DOM nodes using dot notation.
To change this element:

We could change the src attribute this way:
var imgKitten = document.getElementById('kittenPic');
// will return src attribute on image
imgKitten.src
// will set our src to a new src
imgKitten.src = 'http://placekitten.com/g/600/500';
You can also use getAttribute
or setAttribute

We could change the src attribute this way:
var imgKitten = document.getElementById('kittenPic');
// will return src attribute on image
imgKitten.getAttribute('src');
// will set our src to a new src
imgKitten.setAttribute('src', 'http://placekitten.com/g/600/500');
You can change page css using style
To make this CSS:
body {
color: red;
}
Use this JavaScript:
var pageBody = document.getElementsByTagName('body')[0];
pageBody.style.color = 'red';
The rule of thumb in JavaScript is to change CSS styles with a "-
" to camelCase.
To make this CSS:
body {
background-color: pink;
padding-top: 10px;
}
Use this JavaScript:
var pageBody = document.getElementsByTagName('body')[0]
pageBody.style.backgroundColor = 'pink';
pageBody.style.paddingTop = '10px';
Create a simple HTML page or use this sample code.
Isolate a node (an element on the page) and change an attribute or add a new style.
Each DOM node has an innerHTML
property with the HTML and content of its children. You can use the property to view or change the HTML of a node.
For example, you can overwrite the entire body:
var pageBody = document.getElementsByTagName('body')[0];
pageBody.innerHTML = '
Oh Noes!

I changed the whole page!
'
Or just add some new content to the end
pageBody.innerHTML += '...just adding this at the end of the page.';
You can also target one specific element's content
To put content in this paragraph element:

We can select the node and modify it
var warningParagraph = document.getElementById('warning');
warningParagraph.innerHTML = 'Danger Will Robinson!';
The document
object also has methods to create nodes from scratch:
document.createElement(tagName);
document.createTextNode(text);
element.appendChild(element);
var pageBody = document.getElementsByTagName('body')[0];
// create our image tag with attributes
var newImg = document.createElement('img');
newImg.src = 'http://placekitten.com/g/500/200';
newImg.style.border = '1px solid black';
// add our image to the body
pageBody.appendChild(newImg);
// create a paragraph tag with content
var newParagraph = document.createElement('p');
var paragraphText = document.createTextNode('Squee!');
newParagraph.appendChild(paragraphText);
// add our new paragraph to the body
pageBody.appendChild(newParagraph);
Create a new paragraph element and add it to a div
on your page.
An event is an object that is sent when actions take place on your webpage, most often when a user interacts with your webpage.
For example, JavaScript creates an event when a user clicks an element.
element.addEventListener('click', function(event) {
// code to be executed when user clicks
});
There are a variety of events. Some of the more common events are:
You can call a function directly from your HTML code:
<button id="myBtn" onclick="sayHi()">Click Me!</button>
function sayHi (event) {
alert('Hi!');
};
You can call a function from the addEventListener:
<button id="myBtn">Click Me!</button>
var button = document.getElementById("myBtn");
button.addEventListener("click", function (event) {
alert("Hi!");
});
or
var button = document.getElementById("myBtn");
var sayHi = function (event) {
alert("Hi!");
};
button.addEventListener("click", sayHi);
Go back to the sample files you downloaded earlier.
Make some JavaScript code fire after a mouseover
event.
Elements like links and checkboxes have default behaviors determined by the browser. However, the event
object has a built-in method to prevent the default behavior
Our anchor link in HTML
GDI
Code to prevent going to link's href on click
var link = document.getElementById("myLink");
link.addEventListener("click", function(event) {
event.preventDefault();
});
Photo credit: Alan Berning cc
The event's currentTarget
references the element the event listener was attached to.
Our button in HTML:
<button id="myBtn">Click Me!
This code adds styles and text to our clicked button
myButton = document.getElementById("myBtn");
myButton.addEventListener("click", function(event) {
btn = event.currentTarget;
btn.style.backgroundColor = 'red';
btn.innerHTML = 'Clicked!';
};
You may also see code that references the keyword this
as the "target".
Write code that targets this link:
Girl Develop It
When a user clicks the link, the page should display an error message instead of going to the Girl Develop It homepage.
Photo credit: Rym DeCoster cc
You can collect information from users to use in your code. The most common method is an HTML form
<form id="userForm">
First Name:
<input type="text" id="firstName"/>
<input type="radio" name="married" value="Yes" checked /> Yes
<input type="radio" name="married" value="No" /> No
<input type="submit" id="submitBtn" value="Submit" />
</form>
You retrieve the values of form elements using the value
method.
var name = document.getElementById('firstName').value;
console.log(name);
You can retrieve the value of a form at any time. Even when an event like blur
is triggered (when a form element loses focus).
Radio buttons usually do not have IDs, so you will need to use a for
loop to get the value on each radio:
var radios = document.getElementsByName('married');
var length = radios.length;
for (var i = 0; i < length; i++) {
if (radios[i].checked) {
var radioButtonValue = radios[i].value;
// only one radio can be checked, so stop now
break;
}
}
If you are going to retrieve form values with the submit button, be sure to prevent the default action!
var submitButton = document.getElementById('submitBtn');
submitButton.addEventListener("click", function(event) {
event.preventDefault();
var name = document.getElementById('firstName').value;
console.log(name);
})
Collect a value from the input box on the page. Use it inside a function of some kind. For example, collect a number and multiply it by five or collect a name and display a greeting.


Bitvector class with very limited functionality. More...
#include <bmvmin.h>
Public Member Functions | |
| bvector_mini (unsigned size) | |
| bvector_mini (const bvector_mini &bvect) | |
| ~bvector_mini () | |
| int | is_bit_true (unsigned pos) const |
| Checks if bit pos 1 or 0. Returns 0 if 0 and non zero otherwise. | |
| void | set_bit (unsigned pos) |
| Sets bit number pos to 1. | |
| void | clear_bit (unsigned pos) |
| Sets bit number pos to 0. | |
| unsigned | bit_count () const |
| Counts number of bits ON. | |
| int | compare (const bvector_mini &bvect) |
| Comparison. | |
| unsigned | get_first () const |
| Returns index of the first ON bit. | |
| unsigned | get_next (unsigned idx) const |
| Returns index of next bit, which is ON. | |
| void | combine_and (const bvector_mini &bvect) |
| void | combine_xor (const bvector_mini &bvect) |
| void | combine_or (const bvector_mini &bvect) |
| void | combine_sub (const bvector_mini &bvect) |
| const unsigned * | get_buf () const |
| unsigned | mem_used () const |
| void | swap (bvector_mini &bvm) |
Bitvector class with very limited functionality.
Class implements simple bitset and used for internal and testing purposes.
Definition at line 278 of file bmvmin.h.
| bm::bvector_mini< A >::bvector_mini | ( | unsigned | size | ) | [inline] |
| bm::bvector_mini< A >::bvector_mini | ( | const bvector_mini< A > & | bvect | ) | [inline] |
| bm::bvector_mini< A >::~bvector_mini | ( | ) | [inline] |
| unsigned bm::bvector_mini< A >::bit_count | ( | ) | const [inline] |
Counts number of bits ON.
Definition at line 330 of file bmvmin.h.
Referenced by bm::bvector_mini< A >::compare().
| void bm::bvector_mini< A >::clear_bit | ( | unsigned | pos | ) | [inline] |
| void bm::bvector_mini< A >::combine_and | ( | const bvector_mini< A > & | bvect | ) | [inline] |
Definition at line 433 of file bmvmin.h.
References bm::bvector_mini< A >::get_buf().
| void bm::bvector_mini< A >::combine_or | ( | const bvector_mini< A > & | bvect | ) | [inline] |
Definition at line 458 of file bmvmin.h.
References bm::bvector_mini< A >::get_buf().
| void bm::bvector_mini< A >::combine_sub | ( | const bvector_mini< A > & | bvect | ) | [inline] |
Definition at line 470 of file bmvmin.h.
References bm::bvector_mini< A >::get_buf().
| void bm::bvector_mini< A >::combine_xor | ( | const bvector_mini< A > & | bvect | ) | [inline] |
Definition at line 445 of file bmvmin.h.
References bm::bvector_mini< A >::get_buf().
| int bm::bvector_mini< A >::compare | ( | const bvector_mini< A > & | bvect | ) | [inline] |
Comparison.
Definition at line 344 of file bmvmin.h.
References bm::bvector_mini< A >::bit_count(), bm::bvector_mini< A >::get_first(), and bm::bvector_mini< A >::get_next().
| const unsigned* bm::bvector_mini< A >::get_buf | ( | ) | const [inline] |
Definition at line 482 of file bmvmin.h.
Referenced by bm::bvector_mini< A >::combine_and(), bm::bvector_mini< A >::combine_or(), bm::bvector_mini< A >::combine_sub(), and bm::bvector_mini< A >::combine_xor().
| unsigned bm::bvector_mini< A >::get_first | ( | ) | const [inline] |
Returns index of the first ON bit.
Definition at line 382 of file bmvmin.h.
Referenced by bm::bvector_mini< A >::compare().
| unsigned bm::bvector_mini< A >::get_next | ( | unsigned | idx | ) | const [inline] |
Returns index of next bit, which is ON.
Definition at line 408 of file bmvmin.h.
Referenced by bm::bvector_mini< A >::compare().
| int bm::bvector_mini< A >::is_bit_true | ( | unsigned | pos | ) | const [inline] |
| unsigned bm::bvector_mini< A >::mem_used | ( | ) | const [inline] |
| void bm::bvector_mini< A >::set_bit | ( | unsigned | pos | ) | [inline] |
| void bm::bvector_mini< A >::swap | ( | bvector_mini< A > & | bvm | ) | [inline] |


Marvin is an AI powered tool for stylistic language editing. It leverages a combination of recent Natural Language Processing (NLP) and deep learning innovations in text classification and generation as well as visualization and interpretation techniques. Marvin provides the ability to classify the style of texts, transfer to other styles as well as understand how certain features contribute to style. It strives to adhere to a machine-in-the-loop framework, where writing is performed normally by human users, but is aided by algorithmic suggestions.
We evaluated the machine learning models that comprise Marvin on several benchmark metrics and determined that these models are able to perform well on linguistic style tasks. One of Marvin’s primary novel contributions is the ability to transfer to different specific levels of a particular style. It also can perform joint style analysis and transfer for several dimensions of style simultaneously.
At the School of Information we find ourselves at the intersection of cutting edge research and a will to democratize access to such research. Throughout history, the written word has played a vital role in expanding the horizons of human consciousness. And effective use of stylistic language is ubiquitous in this pursuit, from scientific text and Wikipedia to the writings of Shakespeare and Mahatma Gandhi. Unfortunately, language famously suffers from issues of bias, accessibility and quality control. Anyone who has ever made a Wikipedia edit or has written a technical blog post immediately recollects the dozens of examples one has to pore over, to emulate the style, objectivity and tenor of the writing style. Adherence to a particular style can often be used as a proxy measure of value. At best, this leads to a high variance in quality, and at worst, it makes the process of writing entirely prohibitive to newcomers. We believe that a system, such as Marvin, will help users generate style-conformant content and can democratize access to domains for fledgling writers from various backgrounds.
Marvin in action!
This is part of the MIMS Capstone Project by Daniel, Priyam and Vivek, advised by Marti Hearst and Dongyeop Kang. We believe that Marvin is the next generation of writing aids. We're building Marvin for all the hitchhikers, out there in the galaxy. Don't panic!
Features
The primary goal of Marvin is to help people write style-conformant content. We do this in two ways. Firstly, we give users analysis on their sentences so that users themselves can write better content. Secondly, we provide suggestions for transfer into a target style while retaining the semantic meaning of the sentence.
- Classification of text along different style axes Including macro-styles like Shakespeare, Wikipedia, Scientific Abstracts and micro-styles like formaltiy, emotions
- Transfer of text from one style to another Eg: Modern English → Shakespearean
- Transfer of text from one point of a style spectrum to another (Intensity Transfer) Eg: Mid Formality → High Formality
- Transfer of text to a combination of multiple styles Eg: Low Formality and Happy → High Formality and Sad
- Visualization of feature importance for styles to understand how each word contributes to scores
- Record user actions and generate new datasets forming a closed machine-in-the-loop system
Synopsis: Style transfer is a really hard task to deal with all the nuance. We think NLP must aid people to write in an appropriate style. To address this problem, we present Marvin. Marvin is a text editor, which allows users to convert text into new styles. It has state-of-the-art advances in the field of ML. This website focuses on our efforts, models, and evaluations.
This synopsis of its own abstract was generated by Marvin.
Input : "summary, style transfer’s really hard bcoz of all the nuance. we think NLP’s gotta help people write in appropriate style. presenting Marvin, to solve this problem. Marvin’s a text editor that allows users convert text to a new style. It has the latest advances in ML. this website has our efforts, models n evaluations"
Research
The development of Marvin involved implementing and integrating several recent state-of-the-art machine learning approaches along with our own novel contributions.
Why style transfer is hard : Style transfer vs Stylistic Auto-complete
In style transfer, we want to rewrite a sentence in a style of our choice. This is different, and much harder from stylistic auto-complete which can be achieved by training a language model on a style corpus. Note that we have little control over the content we write in style auto-complete, whereas in transfer, we want to preserve the semantic meaning of the input. So, could we just consider style as a new language and model style transfer as Machine Translation? Not quite. Though this is a popular approach, parallel datasets are few and far in between. Also, it is unreasonable to get parallel pairs for all style combinations. On top of this, styles are also fuzzy and may be correlated (politeness vs formality), they can be comprised of more styles (Wikipedia style is formal, neutral, etc.), or coupled inseparably with the content (emotion - sadness, happiness). Marvin addresses a lot of these issues in its implementation.
Components:
Marvin is composed of a number of neural network models and related methodologies that play different roles. Below is a summary of the different components that comprise Marvin and how they relate to one another.
- Joint classifier models which classify text inputs on
multiple style
axes.
- These are custom models adjusted from pretrained DistilBERT models provided by HuggingFace.
- The lightweight joint classification models are notably more efficient than normal single classifiers.
- They also enabled the creation of pseudo-labels for joint datasets that allow for the possibility of joint transfer.
- Paraphraser model which paraphrase texts to a more neutral style.
- Fine-tuned from a T5-small model.
- This is inspired by the approach from STRAP.
- These create pseudo-parallel datasets needed for transfer training.
- Transfer models for three different types of transfer (intra-style,
joint, and binary):
- Also fine-tuned from T5 models.
- The joint models which can transfer along multiple style axes simultaneously and the intra-style capabilities enabling transfer to different style intensities are novel contributions to this approach.
- Saliency mapping methods for determining how much input words affect the style score.
Example of salience map for an informal input, demonstrating how each token contributes to the score.
Methods: The full details of Marvin’s inner workings are described in our report, but the main steps of the approach are:
Training- Train classifiers to predict styles of texts from labelled data.
- Train paraphraser to paraphrase texts and strip style.
- Use paraprahser to generate a pseudo-parallel dataset.
- Use classifiers to give style scores to original texts and paraphrases.
- The joint classifiers allow us to get multiple styles axis scores.
- Split the style scores into discrete bins.
- Use the pseudo-parallel data along with scores to train transfer models.
Diagram of model training flow. This illustrates a main strength of our approach, that parallel data is not required but is generated.
Evaluation and Use
For a given input sentence, we can perform analysis and transfer in the following way:- Use classifiers to get style scores.
- Apply saliency to understand how words contribute to style scores.
- Run paraphraser and transfer model to create candidate transfers in desired style.
- Use classifiers and other evaluation methods to rank best transfers and determine new style scores.
- Provide best transfers and their analyses.
- Repeat as desired!
Datasets Created:
In addition to the models that were built while developing Marvin, we also assembled several datasets. These include:
Limitations and Challenges
While we believe that Marvin has made exciting progress on the challengeing task of neural style transfer, there are certainly some shortcomings. This work is still at a relatively early stage and hopefully future work could address some of these limitations. Below are some of the ways in which Marvin's performance is limited.
Conclusion
Unique Contributions and Stengths:
We're incredibly excited for the direction Marvin can take, both in terms of Research and the application itself. We think Marvin is the next stage in the evolution of text editors and writing tools, making domain specific writing more accessible to people all over the world.Do check out our demo and write away!


Netizen Slams Another For Saying That We Have Too Many Annual Leaves
by Fadzly HanaffiTap to listen to this article instead: 🔊 Listen to Post
With extreme prejudice, netizen @aizadfahmy slammed a fellow, who shall not be named in this article for safety purposes, for suggesting that we Malaysians have too many annual leaves.
In the original tweet, the netizen writes, “We Malaysians have too many holidays. Annual leaves. Paternity leaves.”
“If you know you are about to have children you should have planned your leaves earlier.”
The tweet which came from a netizen who lacks volition or basically has no idea what he was talking about, drew flak from netizens, most importantly from @aizadfahmy.
Slamming the netizen @aizadfahmy writes, “This disgusts me especially the second last part. Did you know that employees in developed countries enjoy a minimum of 20 days leave and we only get 14?”
“Moreover other countries offer 16-month paternity leave with employees paying 80% of their salary because they realize how important it is for the children.”
Clearly angry he continued his rant in the subsequent tweet, he mentions that the Swedes enjoy 20 days worth of public holidays, with 16-month paternity leave, adding that the netizen does not know what he is talking about.
Netizens were of course in support of what @aizadfahmy had to say, with 14k retweets and 8k likes.
In truth, we too agree with the statement that we do not have enough day-offs, nobody would say no to more off days, right?
It is important to note that a recent survey published in NST states that Malaysian employees are overworked, sleep-deprived and unhealthy.
We sincerely hope that more could be done to better working conditions in Malaysia, not all of us can afford to go overseas and work right?
Also read: Study: More Than Half of Malaysian Employees are Overworked and Suffer Sleep Deprivation


I was first introduced to NoSQL when Solr was thrust upon me as a searchable document store. It was a fantastic solution to a scaling problem we had. It allowed us to offload most of our document searching from our relational database to another service. It was a fantastic combination of tooling which complemented each other so well.
We want tech, without the tech
As with most things, somebody took it too far. They realised that the document store could be used as their primary database. “NoSQL” was born1.
Akin to the fad of recent years focused around “no code”2 the drive to produce products without the use of code is an interesting one, if not somewhat naive.
Who are you calling naive?
Many tech startups begin in the same way. A rapidly hacked together proof of concept intended as a short term solution to prove an idea. We promise ourselves that we’ll replace it with a well engineered and architected approach. The re-imagined solution will be clean and free from the hacks. It will help the company to grow along its hockey stick trajectory as we’re all led to believe every startup does.
Ask any startup CTO and they’ll all tell you the same thing. Plans change. You begin to find your place in the market. new features are needed, and that initial proof of concept grows. It becomes your platform, and there isn’t time or resource to do things properly anymore.
This isn’t always a bad thing. A good team of engineers will gradually re-engineer your approach as you improve areas of functionality, add appropriate testing, automate deployments, etc. You move towards a system which is no longer proof of concept, and production ready. Sometimes that isn’t possible and you take the strangler approach which can take longer, but gets you there in the end.
What does this have to do with NoSQL?
Your business needs to be up and running with something quick. You don’t know exactly how the business is going to need to pivot to find its space in the market. You need to iterate quickly.
Traditional relational databases require prior knowledge about the structure of the data that you’re going to store. When that structure changes you may have difficulty adapting your platform to use the new structure, or it might take a lot of time to make the changes3.
A relational database has a rigid structure, has relationships, and all of that needs to be modified when the product changes.
Enter NoSQL. No structure. No changes. No problem?
Data, data, data!
Wait a moment, the use of data is a big thing now. We need to be able to extract information from the data that we gather from our users so that we can produce insights that can direct the business. Google Analytics can only take you so far before being able to understand a bit more about your users, and how they interact with your platform.
Suddenly the choice for using NoSQL rather than a structured database format lets you down. While you were quick to get something up and running, more than likely it’s not possible for you to perform even the most basic analysis of the data you’ve gathered, or build products on the back of it.
Some of the features that you’re likely to want are available by third party platforms (£££) but many of the insights won’t be. For example, tracking a history of changes for an entity becomes difficult, or analysing search patterns to find out how people look for products.
Becoming data driven
As mentioned, there is always the possibility of dropping in third party tools, though you will end up paying good money for them at a time when the business perhaps can’t afford it. Sometimes they will be better, and you’ll use them anyway.
For other things you have little choice but to move to some sort of data pipeline to allow you to track user events, and model their behaviour in a way that allows you to understand how they use your platform, and where they aren’t engaging in a way you’d like. This is costly as you’ll need a team of people to build this, you’ll need new skills, and it’s an entire product in itself. Resources you could spend elsewhere.
Whichever method you choose you cannot regain what you’ve lost - data about how your customers have been performing before now. You might be able to normalise the data you have in NoSQL and load them into your choice of analytics tool, but that relies on your data being well formed and validated, which is rarely front of mind when diving into a NoSQL solution.
So when should I use NoSQL?
Historically, relational databases are exceptional at what they do, all the way up to the point where they hit a scaling limit. Whether it’s I/O, memory, CPU, or something else, the cost of scaling further becomes increasingly expensive. Sharding, replicas, clustering - whatever your database offers, the complexity increases exponentially.
Most platforms will introduce some sort of caching layer to alleviate some of the load, and buy you some time, but this only helps up to a point.
During this scaling process many platforms reach a point in their evolution where a denormalised representation of their data stored in a NoSQL document store makes sense. It offers rapid retrieval of dependant data with a single retrieval, rather than many. This is where NoSQL really comes into its own. By re-engineering your platform to offload some of your data retrieval onto the NoSQL document store you can increase the horizontal scalability of your platform considerably.
Avoiding the trap
Some businesses are lucky enough that they reach a stage in their growth where relational database scalability becomes expensive, and at that stage then turning to a NoSQL solution makes absolute sense. Almost all platforms will reach a stage where they need to perform analytics of the data they have in their platform to assist in growth, and those that use a NoSQL database as their primary datastore will hit problems at this point, and spend significant funds trying to resolve this hole in their platform.
I have yet to see a company that started with a NoSQL database as their primary datastore not hit painful problems when it comes to all of the things that I’ve discussed in this article. There are always countless reasons why it was the right decision, even in the face of the facts. It’s expensive, it’s hard to “fix”, and it forces you to grow before you’re ready, or in a way that is not top priority.
Common reasons I’ve heard.
We needed to move fast!
Structure does not slow you down, if done properly. Use an appropriate database migration tool, and don’t be afraid to make changes that need to be made.
Relational databases are too slow!
 I’m sure there are some.
Appropriate use of indexes and appropriate field types is all you need. Don’t be afraid to break the rules around normalisation either, engineers may be idealists, but the best solutions rarely are.
Nobody knows SQL
This is a tough one. ORMs can help you here, as can any one of the million relational frameworks available for your language of choice.
My advice here would be - learn SQL. Understanding the data you’re processing and how to query it effectively will be invaluable down the line.
We have no idea what [specific] data is going to look like!
PostgreSQL never fails to impress me, and it has a wonderful datatype for exactly this purpose. It can be queried, it can be indexed, and PostgreSQL is FAST.
We want to use the newest technology!
Boring technology always trumps the cool kid on the block. This will be my next article!
Summary
Set yourself up for success. You owe it to the company you’re building to have a little maturity in your tech, and save yourself a lot of headaches in the future. Adopt data early, and use it to grow even faster!
I hope your business reaches a scale where you need a real data pipeline, and a team dedicated to it. A team which can operate autonomously, and run experiments without months of product development. I also hope that you choose to go down that path when you need it, and that you don’t have it forced upon you due to technical myopia.
Footnote
-
I have nothing to back this claim up, this is just how it seemed to happen to me. ↩
-
Which almost certainly follows on from the concept of NoSQL4. ↩
-
A future blog post will cover the idea of “functional abstraction”, a term coined by a colleague to describe a code style adopted at the time which allowed for rapid iteration and re-factoring as you go to resolve issues. Ideal for startups. ↩
-
Likewise. ↩


Welcome to my personal portfolio website! This site contains all of the information there is to know about me, including my passions and skills. Please feel free to use the menu above to explore, and I hope you enjoy!


This examples adds an LCARS-style border around a static plot. Keep in mind that while the lcars_border
function below takes a ggplot object, the result is not a returnable ggplot object. The function uses the grid
package underneath the hood and draws the necessary elements using viewports.
library(lcars)
library(trekcolors)
library(ggplot2)
library(grid)
library(png)
logo <- rasterGrob(readPNG(system.file("stlogo-white.png", package = "lcars")))
clrs <- c("#FF3030", "#FFFF33", "#20B2AA")
g <- ggplot(iris, aes(Sepal.Length, Sepal.Width, color = Species)) +
geom_point() +
theme_lcars_dark() +
coord_cartesian(clip = "off") +
annotation_custom(logo, xmin = 9.4, xmax = Inf, ymin = 3.6, ymax = Inf) +
scale_color_manual(values = clrs)
len_frac <- c(0.55, 0.25, 0.2, 0.4, 0.1, 0.2, 0.1, 0.1)
n_seg <- c(1, 2, 0, 8)
corner_colors <- c("chestnut-rose", "lilac", rep("pale-canary", 2))
side_colors <- list("pale-canary", c("anakiwa", "lilac"), NA,
c("#000000", rep("anakiwa", 2), rep("orange-peel", 5)))
side_labels <- list(
"R 47.0.2", c("47", "B4"), NA,
c("LCARS", "47174-A", "...", "O'Brien", "Lefler", "La Forge", "Barclay", "Argyle"))
lcars_border(g, corners = 1:3, length_frac = len_frac, side_n_segments = n_seg,
corner_color = corner_colors, side_color = side_colors,
side_label = side_labels, label_size = 0.7)
text(2.8, 0.1, "Iris dataset (classic Terran flora sample)",
col = lcars_colors("anakiwa"), font = 2, cex = 0.7)
text(7.55, 0.1, "LCARS BETA R Interface v0.0.1",
col = lcars_colors("pale-canary"), font = 2, cex = 0.7)
As you can see, a decent plot is still going to take some customization with additional commands in order to give it the level of polish it deserves.
But this is just the appetizer; next is the Shiny version.
In the lcars
package, functions whose names are lowercase and contain underscores deal with general R use. Functions whose names use camel case are related to Shiny.
First, use lcarsPage
to set up the Shiny UI. This is a wrapper around Shiny’s bootstrapPage
. It loads the required CSS and other assets.
There are several functions you can explore. There are a handful of simple wrappers around various Shiny inputs that give them an LCARS aesthetic, but not many currently and they will continue to be improved upon in subsequent package versions.
The primary function of interest is lcarsBox
. This is the container that captures the LCARS style. Additional functions worth focusing on include lcarsHeader
for breaking up sections of the UI; also lcarsButton
and lcarsToggle
, which in conjunction with buttonColumn
produce column inputs that fit well into the sidebars of an lcarsBox
.
Here is a simple example.
if (interactive()) {
ui <- lcarsPage(
lcarsBox(
fluidRow(
column(3,
h4("Main panel area"),
HTML("
Some paragraph text and a link
with LCARS styling.

Use lcarsPage
to apply the LCARS theme and lcarsBox
to draw a characteristic box for framing content.

Many of the lcarsBox
properties are configurable.
See lcars::lcarsApp(\"box\") for a demo
")
),
column(9, plotOutput("plot1"))
),
title = "box title",
left_inputs = buttonColumn(lcarsButton("btn1", "A button"))
)
)
server <- function(input, output) {
output$plot1 <- renderPlot({
hist(rnorm(500))
})
}
shinyApp(ui, server)
}
Rather than post lots of code here in a non-interactive package vignette, the best suggestion is to explore the example apps included in the package. The source code is easy to browse in the GitHub repository.
Use lcarsApp
to loads various demo apps:
lcarsApp("demo")
lcarsApp("box")
lcarsApp("sweep")
lcarsApp("toggle")
lcarsApp("elements")
lcarsApp("leaflet")
The box
example is helpful for exploring the many ways you can control the style of an lcarsBox
. Here are a couple examples highlighting some of the versatility:
Pay attention to the arguments to lcarsPage
. Depending on the nature of text content in your app, you may find you need to deviate from some LCARS-style defaults (e.g., uppercase font) to make the text in your app more pleasant to read. It will also allow you to revert to sans serif. It is not an all or nothing switch; you have some control over what to change and what to leave alone.
In adhering closely to sizing and layout rules for LCARS UI design, fixed sizing works best for some container widgets like lcarBox
and lcarsSweep
. You can use settings like width = "100%"
for these containers, but you may notice limitations in maintaining a responsive UI, particularly when they contain plot outputs. Fixed width widgets are generally recommended.
Visual components such as the LCARS elbow shape underlying some widgets are intended to follow strict sizing and scaling rules. They are not intended to scale arbitrarily or fit well on very small device screens.
Familiarize yourself with LCARS colors from the trekcolors
package. This package is a dependency of lcars
. It includes various other Star Trek color palettes. Most notably it includes a function for previewing the palettes.
There are several generations of LCARS color palettes. The lcarsdata
dataset in lcars
provides a convenient data frame of the four main series of LCARS color palettes with official color names, but trekcolors
offers several helpful functions related to LCARS colors, including LCARS-themed scale_*
functions for use with ggplot2
.
head(lcarsdata)
#> series name value
#> pale-canary 2357 pale-canary #FFFF99
#> tanoi 2357 tanoi #FFCC99
#> golden-tanoi 2357 golden-tanoi #FFCC66
#> neon-carrot 2357 neon-carrot #FF9933
#> eggplant 2357 eggplant #664466
#> lilac 2357 lilac #CC99CC
library(ggplot2)
library(trekcolors)
lcars_colors()
#> pale-canary tanoi golden-tanoi neon-carrot
#> "#FFFF99" "#FFCC99" "#FFCC66" "#FF9933"
#> eggplant lilac anakiwa mariner
#> "#664466" "#CC99CC" "#99CCFF" "#3366CC"
#> bahama-blue blue-bell melrose hopbush
#> "#006699" "#9999CC" "#9999FF" "#CC6699"
#> chestnut-rose orange-peel atomic-tangerine danub
#> "#CC6666" "#FF9966" "#FF9900" "#6688CC"
#> indigo lavender-purple cosmic red-damask
#> "#4455BB" "#9977AA" "#774466" "#DD6644"
#> medium-carmine bourbon sandy-brown periwinkle
#> "#AA5533" "#BB6622" "#EE9955" "#CCDDFF"
#> dodger-pale dodger-soft near-blue navy-blue
#> "#5599FF" "#3366FF" "#0011EE" "#000088"
#> husk rust tamarillo
#> "#BBAA55" "#BB4411" "#882211"
lcars_colors("melrose")
#> melrose
#> "#9999FF"
view_trek_pals(c("lcars_2357", "lcars_2369", "lcars_2375", "lcars_2379"))
ggplot(diamonds, aes(carat, stat(count), fill = cut)) +
geom_density(position = "fill") + scale_fill_lcars("2357")
Functions in lcars
that accept color arguments will take any hex color, but will also accept official LCARS colors by name.


Basic Info
A smooth scrolling library built to provide convenience for developers.
If you like this project you may like our durations.js animated durations library!
Features
- Plug-and-play (unless you have other JavaScript that uses
scrolls()
already...) - Number or selector-based targeting
- Allows a function to be called when scrolling has ended
- Customizeable duration of movement and offset position from the stop position
- Fully open source
Getting Started
Installation
You can install the libaray via npm:
npm i scrolls.js
or via CDN:
Source Version

Landing Page
Are you building a landing page and want to have smooth scrolling from a navigation bar to the different sections of the page? Just copy-and-paste the code below, tweak it to match your environment, and you should have the section scrolling functionality you should be be able to experience here.
HTML:

Features
Pricing
Team
Contact

Somewhere further down or up the page...

Features

Pricing

Team

Contact

CSS:

JS:

That's it! If you copied the HTML and CSS from the Back-To-Top example from above you should have that functionality as well. Unless you have other code that would interfere with the selectors/styling you should be able to just plug-and-play with these examples!!
Documentation
// Default customizeable variables via an object within the second parameter
// of the function.
let callback; // Function to execute after scrolling has ended
let durationOfMovement = 1000; // Duration of the scrolling
let offsetPosition = 0; // Distance to offset from the stop position
// Pass in an object as the second parameter to customize the behavior.
scrolls('h1', {
callback: () => {
console.log('Scrolling has finished.');
}
});
// The first parameter could be a number or string and is used as the target of
// the scrolling event, for example 0 would be the top of the page, or h1 to
// scroll to the first h1 element.
Changelog
Please see CHANGELOG.md for details.
License
MIT
Copyright © 2018 Purplest, Inc.


Verified
1 Abhishek Thakkar (Primary Traveller)
2 Arpit Singh
Easy-2
+Extra Baggage Cover
890 บาท
Credit Card Payment
Card Number
Name on Card
Valid Till
CVV


We use stripe to securly process your donation. We never store your card information!
{{error.message}}


@(ccTableHTML: scala.xml.Elem)
These are the Common Curriculum classes that fit within your time preferences and do not conflict with a class you are taking for your major. Please select all you would like to take. There is an additional step where you may select non-Common Curriculum classes if you so wish.
Understanding Cultural Heritage


#include <stddef.h> size_t offsetof(type, member);
This macro is useful because the sizes of the fields that compose a structure can vary across implementations, and compilers may insert different numbers of padding bytes between fields. Consequently, an element's offset is not necessarily given by the sum of the sizes of the previous elements.
A compiler error will result if member is not aligned to a byte boundary (i.e., it is a bit field).
$ ./a.out offsets: i=0; c=4; d=8 a=16 sizeof(struct s)=16
#include <stddef.h> #include <stdio.h> #include <stdlib.h> int main(void) { struct s { int i; char c; double d; char a[]; }; /* Output is compiler dependent */ printf("offsets: i=%zd; c=%zd; d=%zd a=%zd\n", offsetof(struct s, i), offsetof(struct s, c), offsetof(struct s, d), offsetof(struct s, a)); printf("sizeof(struct s)=%zd\n", sizeof(struct s)); exit(EXIT_SUCCESS); }


--- layout: page title : Schedule header : Schedule group: navigation --- {% include JB/setup %}
On this page you can find my future and past conference and other speaking appearances, chronologically ordered from newest to oldest. The top entries may be in the future.
Note that some conferences reuse the same URL from one year to the next, so links may either be dead, or point to a newer incarnation of the conference.
Future Dev Day
Workshop
Build Stuff 2017
DotNext 2017
.NET Fest 2017
GOTO Copenhagen 2017
Mødegruppe for F#unktionelle Københavnere
Build Stuff Summer 2017
DDD Greece
NDC Mini Copenhagen
Copenhagen .Net User Group
Copenhagen .Net User Group
NDC London 2017
Build Stuff 2016
Dev#
CODE Odense
F# Sydney
NDC Sydney
Copenhagen .Net User Group
Techorama 2016
F# eXchange 2016
New York City F# User Group
Software Architecture Summit 2016
Copenhagen .Net User Group
fsharpConf
Mark Seemann on Software Craftsmanship
NDC London 2016
Øredev 2015
GOTO Copenhagen 2015
NDC Community Tuesday
NDC Oslo 2015
NCRAFTS France 2015
Techorama 2015
F# eXchange 2015
WROC#
.NET User Group Hamburg
Beauty in Code


This is a tool to help look up funding statistics for NSF programs. In some cases that is useful for proposal preparation, as you can verify that your budget is not significantly outside of the funding profile for the program. However, when in doubt, you should always talk to the program officer.
Finally, although this project uses NSF's API, it is not support, condoned, or endorsed by the National Science Foundation.
The entirety of this project is hosted in this Github repo. Lend a hand!


|
SUBJECT INDEX Anthropology Architecture Art Black Studies Business Ecology Economics Education Film Healthcare History Law Linguistics Literature Mass Media Medicine Music Philosophy Political Science Psychology Religion Science Shakespeare Sociology Sports Recreation Urban Studies Women's Studies |
Medicine & Healthcare: Mid-life to GeriatricTo order a specific paper, click the Catalog Number button next to the Paper Title of interest. Send comments to<EMAIL_ADDRESS>Last Updated: 12/21/96 Copyright ©1996 ASM Communications, Inc. All Rights Reserved. |


Surfing Dirt
A social network built in React / GraphQL / Node / PHP
I wrote a detailed blog post on the project.
Interesting bits
- the translation process
- tracing
- no-JS
Code samples
- React: comment list ([Github repo])
- GraphQL: translation resolver ([Github repo])
- REST API: JWT model ([Github repo])


Awesome! We found {{$ctrl.frCard.to.name}}, want to send a friend request?
Can't find that user, do you want to invite them to StartSomething?
You're already friends with that user
That user is waiting for you to respond to their friend request!
You've already sent that user a request


Home
(current)
About Me
(current)
My Bookshelf
(current)
My Bookshelf
Title
Year Published
Publisher
Page Count
MSRP
{{ book.titleName }}
{{ book.yearpublished }}
{{ book.publisher }}
{{ book.pagecountx }}
{{ book.msrp }}
Add Book
Title
Year Published
Publisher
Page Count
MSRP
Submit


Candys's Make up is a responsive website designed for a beauty salon entrepreneur in need for a new online presence.
Candy's Make up approached me to design and develop a website for a starting business
Candy's Makeup wanted a design that has a 1920's jazz age look and feel. From the start, Candy's makeup was designed to be fully responsive and cross-browser compatible. The main focus would be to create a good first impression in the first customer touchpoint with the help showcasing previous works and making the call to action by contacting and booking effortless through the website.
A static, cross-browser and responsive website built for a hair salon.
I offered to make my first website for HiusStudio Katja Kähäri
The client wanted to have a homepage design that is streamlined, static and minimalistic that represents the business owners brand identity. The information a was planned together with the client to include the following sections:
A concept for a web app to matchmake skills. Made with HTML, CSS, Javascript, jQuery, Material design and Laravel Elixir PHP framework.
Developing a web app as a software engineering project.
We won a Startup idea competition together with two friends from my university with our concept for a web app to matchmake skills. We decided to see how far we can develop it. The project was joined by other software engineering students and we built a series of prototypes and an MVP version of the web app to be used for usability testing and feedback.
A responsive, cross-browser website for a tattoo artist.
I was approached to design a website for a tattoo artist
The client wanted to have a homepage with minimalistic design yet careful attention to details and high quality images of previous works.


A principal full stack web developer and a team lead, with outstanding (Python | Java | PHP | Django | Flask | Laravel) experience and excellent (Machine learning / Deep learning) skills.
Has over 7 years of working experience in the software development field, building projects for the web and IoT platforms, using different programming tools like Python, PHP, JavaScript, Shell, HTML & CSS.
Tensorflow, Keras, Scikit-learn, pandas, spacy, Numpy, NLP, Deep learning, Machine learning, Flask
Client: Kayak, Lola travel, Travelliance
Developing a natural language multi-turn interactive bot, to be hosted within a distributed
Flask-based python web service. The bot service is conversational context and disambiguate
references, allowing for multi-turn interactions.
Parsing trips emails for extracting the entities using NLP / machine learning.
Developed text classification models in tensorflow for NLP problem.
Developed the CCN models in tensorflow for image classification problem.
Building and managing new features and integrations with third party services.
Responsible for the code deployment on the staging and Production environment on AWS
Services.
Responsible for full release cycle of the project.
Responsible for the code deployment on the staging and Production environment on AWS
Services.
Detecting and optimizing the performance bottlenecks and provide technical guidance to the team.
Peer code reviews.
Machine learning Engineer.
Team lead.
Django, Android, Laravel, Angularjs, Python, Java, PHP, Javascript
Developed enterprise web apps with AngularJS, Django, ElasticSearch and Docker.
Responsible for coming up with user stories and leading technical meetings in the company.
Developed the Android app for Web API in java.
Building, testing and documenting highly available RESTful APIs.
Architecting and developing web applications in Laravel PHP and Angularjs.
Team lead.
Client communication.
Laravel, Zend Framework, Magento, Wordpress, Joomla, woo-commerce, Jquery, PHP, Html, Javascript
Developed scalable API based systems with Laravel.
Developed the E-commerce solutions in Magneto.
Provide the customized CMS solution in PHP.
Blog base CMS in WordPress and Joomla.
Leveraged the open source modules i.e. Mailchimp for mailing service and stripe for building
payment system.
I'm currently taking on freelance work.
I can help with the following:
Drop me a line at<EMAIL_ADDRESS>or call me at 92 3320 453648


Selected Courses
{
Database Design I
: 20/20
{
Formal Methods In Software Development
: 20/20
{
Operating Systems
: 19.2/20,
Lab
: 20/20
{
Software Engineering I
: 19.42/20,
Lab
: 19.5/20
{
Software Engineering II
: 19.1/20,
Lab
: 18.8/20
{
Technical & Scientiﬁc Presentation
: 20/20
{
Electronic Commerce
: 19.5/20
{
Multimedia Systems
: 19.3/20
Honors and Awards
2010
Ranked among the Top 1% of the National University Entrance Examination in Iran.
(among 317,605 people)
Membership
2010 – 2014
Linux Lab
, Isfahan University of Technology IT Center
Professional skills
Programming
Languages
C/C++, Python, C#, Java
Web & Mobile Django, ASP.NET, PHP, HTML, JavaScript, CSS, React, Android
Database
MySQL MSSQL, PostgreSQL, Oracle, MongoDB
IDE
PyCharm, Eclipse, Microsoft Visual Studio, Qt Creator
OS
Linux (Ubuntu, CentOS), Microsoft Windows
Languages
Persian
: Native
English
: Fluent
Arabic
: Basic
Hobbies
- Programming
- Ping-Pong
- Swimming
3/3


." generated with Ronn/v0.7.3 ." github.com/rtomayko/ronn/tree/0.7.3 . .TH “GEMFILE” “5” “June 2014” “” “” . .SH “NAME” fBGemfilefR - A format for describing gem dependencies for Ruby programs . .SH “SYNOPSIS” A fBGemfilefR describes the gem dependencies required to execute associated Ruby code. . .P Place the fBGemfilefR in the root of the directory containing the associated code. For instance, in a Rails application, place the fBGemfilefR in the same directory as the fBRakefilefR. . .SH “SYNTAX” A fBGemfilefR is evaluated as Ruby code, in a context which makes available a number of methods used to describe the gem requirements. . .SH “SOURCES (#source)” At the top of the fBGemfilefR, add one line for each fBRubygemsfR source that might contain the gems listed in the fBGemfilefR. . .IP “” 4 . .nf
source “rubygems.org” source “gems.github.com” . .fi . .IP “” 0 . .P Each of these _source_s fBMUSTfR be a valid Rubygems repository. Sources are checked for gems following the heuristics described in fISOURCE PRIORITYfR. . .SH “RUBY (#ruby)” If your application requires a specific Ruby version or engine, specify your requirements using the fBrubyfR method, with the following arguments. All parameters are fBOPTIONALfR unless otherwise specified. . .SS “VERSION (required)” The version of Ruby that your application requires. If your application requires an alternate Ruby engine, such as JRuby or Rubinius, this should be the Ruby version that the engine is compatible with. . .IP “” 4 . .nf
ruby “1.9.3” . .fi . .IP “” 0 . .SS “ENGINE (:engine)” Each application fImayfR specify a Ruby engine. If an engine is specified, an engine version fImustfR also be specified. . .SS “ENGINE VERSION (:engine_version)” Each application fImayfR specify a Ruby engine version. If an engine version is specified, an engine fImustfR also be specified. If the engine is “ruby” the engine version specified fImustfR match the Ruby version. . .IP “” 4 . .nf
ruby “1.8.7”, :engine => “jruby”, :engine_version => “1.6.7” . .fi . .IP “” 0 . .SS “PATCHLEVEL (:patchlevel)” Each application fImayfR specify a Ruby patchlevel. . .IP “” 4 . .nf
ruby “2.0.0”, :patchlevel => “247” . .fi . .IP “” 0 . .SH “GEMS (#gem)” Specify gem requirements using the fBgemfR method, with the following arguments. All parameters are fBOPTIONALfR unless otherwise specified. . .SS “NAME (required)” For each gem requirement, list a single fIgemfR line. . .IP “” 4 . .nf
gem “nokogiri” . .fi . .IP “” 0 . .SS “VERSION” Each fIgemfR fBMAYfR have one or more version specifiers. . .IP “” 4 . .nf
gem “nokogiri”, “>= 1.4.2” gem “RedCloth”, “>= 4.1.0”, “< 4.2.0” . .fi . .IP “” 0 . .SS “REQUIRE AS (:require)” Each fIgemfR fBMAYfR specify files that should be used when autorequiring via fBBundler.requirefR. You may pass an array with multiple files or fBtruefR if file you want fBrequiredfR has same name as fIgemfR or fBfalsefR to prevent any file from being autorequired. . .IP “” 4 . .nf
gem “redis”, :require => [“redis/connection/hiredis”, “redis”] gem “webmock”, :require => false gem “debugger”, :require => true . .fi . .IP “” 0 . .P The argument defaults to the name of the gem. For example, these are identical: . .IP “” 4 . .nf
gem “nokogiri” gem “nokogiri”, :require => “nokogiri” gem “nokogiri”, :require => true . .fi . .IP “” 0 . .SS “GROUPS (:group or :groups)” Each fIgemfR fBMAYfR specify membership in one or more groups. Any fIgemfR that does not specify membership in any group is placed in the fBdefaultfR group. . .IP “” 4 . .nf
gem “rspec”, :group => :test gem “wirble”, :groups => [:development, :test] . .fi . .IP “” 0 . .P The Bundler runtime allows its two main methods, fBBundler.setupfR and fBBundler.requirefR, to limit their impact to particular groups. . .IP “” 4 . .nf
# setup adds gems to Ruby's load path Bundler.setup # defaults to all groups require “bundler/setup” # same as Bundler.setup Bundler.setup(:default) # only set up the default group Bundler.setup(:test) # only set up the test group (but `not` default) Bundler.setup(:default, :test) # set up the default and test groups, but no others
# require requires all of the gems in the specified groups Bundler.require # defaults to just the default group Bundler.require(:default) # identical Bundler.require(:default, :test) # requires the default and test groups Bundler.require(:test) # requires just the test group . .fi . .IP “” 0 . .P The Bundler CLI allows you to specify a list of groups whose gems fBbundle installfR should not install with the fB--withoutfR option. To specify multiple groups to ignore, specify a list of groups separated by spaces. . .IP “” 4 . .nf
bundle install --without test bundle install --without development test . .fi . .IP “” 0 . .P After running fBbundle install --without testfR, bundler will remember that you excluded the test group in the last installation. The next time you run fBbundle installfR, without any fB--without optionfR, bundler will recall it. . .P Also, calling fBBundler.setupfR with no parameters, or calling fBrequire “bundler/setup”fR will setup all groups except for the ones you excluded via fB--withoutfR (since they are obviously not available). . .P Note that on fBbundle installfR, bundler downloads and evaluates all gems, in order to create a single canonical list of all of the required gems and their dependencies. This means that you cannot list different versions of the same gems in different groups. For more details, see Understanding Bundler fIbundler.io/rationale.htmlfR. . .SS “PLATFORMS (:platforms)” If a gem should only be used in a particular platform or set of platforms, you can specify them. Platforms are essentially identical to groups, except that you do not need to use the fB--withoutfR install-time flag to exclude groups of gems for other platforms. . .P There are a number of fBGemfilefR platforms: . .TP fBrubyfR C Ruby (MRI) or Rubinius, but fBNOTfR Windows . .TP fBruby_18fR fIrubyfR fBANDfR version 1.8 . .TP fBruby_19fR fIrubyfR fBANDfR version 1.9 . .TP fBruby_20fR fIrubyfR fBANDfR version 2.0 . .TP fBruby_21fR fIrubyfR fBANDfR version 2.1 . .TP fBmrifR Same as fIrubyfR, but not Rubinius . .TP fBmri_18fR fImrifR fBANDfR version 1.8 . .TP fBmri_19fR fImrifR fBANDfR version 1.9 . .TP fBmri_20fR fImrifR fBANDfR version 2.0 . .TP fBmri_21fR fImrifR fBANDfR version 2.1 . .TP fBrbxfR Same as fIrubyfR, but only Rubinius (not MRI) . .TP fBjrubyfR JRuby . .TP fBmswinfR Windows . .TP fBmingwfR Windows 32 bit 'mingw32' platform (aka RubyInstaller) . .TP fBmingw_18fR fImingwfR fBANDfR version 1.8 . .TP fBmingw_19fR fImingwfR fBANDfR version 1.9 . .TP fBmingw_20fR fImingwfR fBANDfR version 2.0 . .TP fBmingw_21fR fImingwfR fBANDfR version 2.1 . .TP fBx64_mingwfR Windows 64 bit 'mingw32' platform (aka RubyInstaller x64) . .TP fBx64_mingw_20fR fIx64_mingwfR fBANDfR version 2.0 . .TP fBx64_mingw_21fR fIx64_mingwfR fBANDfR version 2.1 . .P As with groups, you can specify one or more platforms: . .IP “” 4 . .nf
gem “weakling”, :platforms => :jruby gem “ruby-debug”, :platforms => :mri_18 gem “nokogiri”, :platforms => [:mri_18, :jruby] . .fi . .IP “” 0 . .P All operations involving groups (fBbundle installfR, fBBundler.setupfR, fBBundler.requirefR) behave exactly the same as if any groups not matching the current platform were explicitly excluded. . .SS “GIT (:git)” If necessary, you can specify that a gem is located at a particular git repository. The repository can be public (fBgithub.com/rails/rails.gitfR) or private (fBgit@github.com:rails/rails.gitfR). If the repository is private, the user that you use to run fBbundle installfR fBMUSTfR have the appropriate keys available in their fB$HOME/.sshfR. . .P Git repositories are specified using the fB:gitfR parameter. The fBgroupfR, fBplatformsfR, and fBrequirefR options are available and behave exactly the same as they would for a normal gem. . .IP “” 4 . .nf
gem “rails”, :git => “git://github.com/rails/rails.git” . .fi . .IP “” 0 . .P A git repository fBSHOULDfR have at least one file, at the root of the directory containing the gem, with the extension fB.gemspecfR. This file fBMUSTfR contain a valid gem specification, as expected by the fBgem buildfR command. . .P If a git repository does not have a fB.gemspecfR, bundler will attempt to create one, but it will not contain any dependencies, executables, or C extension compilation instructions. As a result, it may fail to properly integrate into your application. . .P If a git repository does have a fB.gemspecfR for the gem you attached it to, a version specifier, if provided, means that the git repository is only valid if the fB.gemspecfR specifies a version matching the version specifier. If not, bundler will print a warning. . .IP “” 4 . .nf
gem “rails”, “2.3.8”, :git => “git://github.com/rails/rails.git” # bundle install will fail, because the .gemspec in the rails # repository's master branch specifies version 3.0.0 . .fi . .IP “” 0 . .P If a git repository does fBnotfR have a fB.gemspecfR for the gem you attached it to, a version specifier fBMUSTfR be provided. Bundler will use this version in the simple fB.gemspecfR it creates. . .P Git repositories support a number of additional options. . .TP fBbranchfR, fBtagfR, and fBreffR You fBMUSTfR only specify at most one of these options. The default is fB:branch => “master”fR . .TP fBsubmodulesfR Specify fB:submodules => truefR to cause bundler to expand any submodules included in the git repository . .P If a git repository contains multiple fB.gemspecsfR, each fB.gemspecfR represents a gem located at the same place in the file system as the fB.gemspecfR. . .IP “” 4 . .nf
|~rails [git root] | |-rails.gemspec [rails gem located here] |~actionpack | |-actionpack.gemspec [actionpack gem located here] |~activesupport | |-activesupport.gemspec [activesupport gem located here] |... . .fi . .IP “” 0 . .P To install a gem located in a git repository, bundler changes to the directory containing the gemspec, runs fBgem build name.gemspecfR and then installs the resulting gem. The fBgem buildfR command, which comes standard with Rubygems, evaluates the fB.gemspecfR in the context of the directory in which it is located. . .SS “GITHUB (:github)” If the git repository you want to use is hosted on GitHub and is public, you can use the :github shorthand to specify just the github username and repository name (without the trailing “.git”), separated by a slash. If both the username and repository name are the same, you can omit one. . .IP “” 4 . .nf
gem “rails”, :github => “rails/rails” gem “rails”, :github => “rails” . .fi . .IP “” 0 . .P Are both equivalent to . .IP “” 4 . .nf
gem “rails”, :git => “git://github.com/rails/rails.git” . .fi . .IP “” 0 . .P In addition, if you wish to choose a specific branch: . .IP “” 4 . .nf
gem “rails”, :github => “rails/rails”, :branch => “branch_name” . .fi . .IP “” 0 . .SS “PATH (:path)” You can specify that a gem is located in a particular location on the file system. Relative paths are resolved relative to the directory containing the fBGemfilefR. . .P Similar to the semantics of the fB:gitfR option, the fB:pathfR option requires that the directory in question either contains a fB.gemspecfR for the gem, or that you specify an explicit version that bundler should use. . .P Unlike fB:gitfR, bundler does not compile C extensions for gems specified as paths. . .IP “” 4 . .nf
gem “rails”, :path => “vendor/rails” . .fi . .IP “” 0 . .SH “BLOCK FORM OF GIT, PATH, GROUP and PLATFORMS” The fB:gitfR, fB:pathfR, fB:groupfR, and fB:platformsfR options may be applied to a group of gems by using block form. . .IP “” 4 . .nf
git “git://github.com/rails/rails.git” do
gem "activesupport" gem "actionpack"
end
platforms :ruby do
gem "ruby\-debug" gem "sqlite3"
end
group :development do
gem "wirble" gem "faker"
end . .fi . .IP “” 0 . .P In the case of the fBgitfR block form, the fB:reffR, fB:branchfR, fB:tagfR, and fB:submodulesfR options may be passed to the fBgitfR method, and all gems in the block will inherit those options. . .SH “GEMSPEC (#gemspec)” If you wish to use Bundler to help install dependencies for a gem while it is being developed, use the fBgemspecfR method to pull in the dependencies listed in the fB.gemspecfR file. . .P The fBgemspecfR method adds any runtime dependencies as gem requirements in the default group. It also adds development dependencies as gem requirements in the fBdevelopmentfR group. Finally, it adds a gem requirement on your project (fB:path => '.'fR). In conjunction with fBBundler.setupfR, this allows you to require project files in your test code as you would if the project were installed as a gem; you need not manipulate the load path manually or require project files via relative paths. . .P The fBgemspecfR method supports optional fB:pathfR, fB:namefR, and fB:development_groupfR options, which control where bundler looks for the fB.gemspecfR, what named fB.gemspecfR it uses (if more than one is present), and which group development dependencies are included in. . .SH “SOURCE PRIORITY” When attempting to locate a gem to satisfy a gem requirement, bundler uses the following priority order: . .IP “1.” 4 The source explicitly attached to the gem (using fB:pathfR or fB:gitfR) . .IP “2.” 4 For implicit gems (dependencies of explicit gems), any git or path repository otherwise declared. This results in bundler prioritizing the ActiveSupport gem from the Rails git repository over ones from fBrubygems.orgfR . .IP “3.” 4 The sources specified via fBsourcefR, searching each source in your fBGemfilefR from last added to first added. . .IP “” 0