The prisoners were successful in fleeing after stabbing two security guards.

Berlin ; New York : Springer, [2007]

Asimov, Isaac, 1920-1992, author

Pirani, Simon, author

Ndlovu, Sehliselo, author

Average ticket size of medicine orders has doubled,it says

02:25 - Kyle Simpson Introduction

• Twitter
• GitHub
• Blog
• “Getify”
• You-Dont-Know-JS
• [Pluralsight] Advanced JavaScript by Kyle Simpson

04:43 - Development => Teaching

• Front End Masters

16:20 - Inheritance and Delegation

29:40 - Evolving a Language

36:23 - Cohersion

• Weak Typing, Dynamic Typing
• The Politics of JavaScript by Angus Croll

50:37 - Performance

• The Width Keyword

54:33 - Developer Education Programs and The Skill of Teaching

Picks

• Adam Tornhill: Code, Crime, Complexity: Analyzing software with forensic psychology @ TEDxTrondheim (Aimee)
• Your Code as a Crime Scene: Use Forensic Techniques to Arrest Defects, Bottlenecks, and Bad Design in Your Programs by Adam Tornhill (Aimee)
• Planet Money Episode 704: Open Office (Jamison)
• Zooko's Triangle (Jamison)
• The Barkley Marathons (Jamison)
• React Rally (Jamison)
• X-Men: Apocalypse (Joe)
• America's Got Talent (Joe)
• Overwatch (Joe)
• Stack (Kyle)
• Jeremy Keith: A web for everyone (Kyle)
• Jeremy Keith: Regressive Web Apps (Kyle)

Panel:

Joe 

Amy 

Charles 

Special Guests: 

Eric Simmons 

Albert Pai

In this episode, JavaScript Jabbers talk to Eric Simmons and Albert Pai, the co-founder of thinkster.io, where their team teaches the bleeding edge of javascript technology’s various frameworks and backend. Also, with the recent creation of Stalkblitz, which is the center topic of today discussion. 

Stackblitz it an online VS Code IDE for Angular, React, and a few more others are supported. This is designed to run web pack and vs code inside your browser at blazing fast speeds. Eric and Albert dive into the many different advantages and services available by StackBlitz and thinker.io. 

In particular, we dive pretty deep on:

• Similarities  and differences to Heroku 
• System JS 
• Stacklets  
• Testing and creating an in-browser system file system
• Creating a type of VS Code experience, Working Off Line 
• Updating of the Stacklets
• Deployment tools or exporting 
• Hot Reloading
• Integrated terminals
• Monaco
• Language Services 
• How do you architect this implementation 
• The innovation of browsers
• Guy Bedford 
• Financing vs. Chipotle Burritos 
• Will this product in the future cost money

Links

• thinkster.io
• https://medium.com/@ericsimons/stackblitz-online-vs-code-ide-for-angular-react-7d09348497f4
• @stackblitz 
• stackblitz.com

Picks

Amy

• Promises Series by Andrew Del Prete
• Crossfit 

Joe

• Wholesome Meme
• Sara Cooper

Charles

• Pivotal Tracker 
• MatterMost 
• asana.com
• Zapier

Eric 

• realworld.io 
• David East 

Albert 

• thinkster.io
• Thing Explainer

Panel:

• AJ ONeal
• Aimee Knight
• Joe Eames

Special Guests: Kyle Simpson

In this episode, the JavaScript Jabber panelists discuss light functional JavaScript with Kyle Simpson. Kyle is most well-known for writing the books You Don’t Know JS and is on the show today for his book Functional-Light JavaScript. They talk about what functional programming is, what side-effects are, and discuss the true heart behind functional programming. They also touch on the main focus of functional programming and much more!

In particular, we dive pretty deep on:

• You Don’t Know JS
• Functional-Light JavaScript
• From the same spirit as first books
• JavaScript
• Documents journey of learning
• What does Functional Programming mean?
• Functional programming is being re-awoken
• Many different definitions
• History of functional programming
• Programming with functions
• What is a function?
• “A collection of operations of doing some task” is what people think functions are
• What a function really is
• Map inputs to outputs
• What is a side-effect?
• Side-effects should be intentional and explicit
• The heart of functional programming
• Refactoring
• Can’t write a functional program from scratch
• What functional programming focuses on
• Making more readable and reliable code
• Pulling a time-stamp
• Defining a side-effect
• And much, much more!

Links:

• You Don’t Know JS
• Functional-Light JavaScript
• JavaScript
• Kyle’s GitHub
• @getify

Picks:

Aimee

• What Does Code Readability Mean?
• @FunctionalKnox
• HTTP 203 Podcast

AJ

• IKEA

Joe

• Barking Up the Wrong Tree by Eric Barker
• Workshops in general

Kyle

• GDPR
• The start-up’s guide to the GDPR
• Hatch
• Fluent Conf

Panel: Charles Max Wood

Guest: Kyle Simpson

This week on My JavaScript Story, Charles speaks with Kyle Simpson. Kyle is most well-known for being the writer of You Don’t Know JS. He first got into programming because his friend’s dad was a programmer and he was hooked by the software side of computers. He grew up writing games with QBasic and Turbo Pascal and then in his teens did some client projects. He was very much a self-taught programmer and ended up sticking with it into his career today. They talk about what led him to JavaScript and what he is doing currently.

In particular, we dive pretty deep on:

• Kyle intro
• You Don’t Know JS
• How did you first get into programming?
• Dad’s friend was a programmer
• Dad built computers
• Wrote games with QBasic and Turbo Pascal
• Some client projects in teen years
• Very much self-taught programmer
• CS degree in college
• First professional job at a biotech company
• Do you feel people need to get a CS degree these days?
• Grateful for his degree
• What engineering taught him
• Striving to understand why and how things work
• Don’t need a CS degree but you do need a certain mindset
• Valuable but not necessary
• What led you to JavaScript?
• Web Portal at his college
• What made you want to deepen your knowledge of JS?
• What are you working on now?
• And much, much more!

Links:

• You Don’t Know JS
• JavaScript
• Kyle’s GitHub
• Functional-Light JavaScript
• @getify
• Kyle on Front-end masters

Picks

Charles

• Template Weeks
• Working Out

Kyle

• Fluent Conf
• Node RSA

Chesterman, Simon

Sheppard, Charles (Charles R. C.), author

Online Resource

Hayden Library - TP1150.W36 2018

Online Resource

Online Resource

This is how I am deploying the build of my static website to staging and production domains. It requires basic use of the CLI, Git, and SSH. But once you’re set up, a single command will build and deploy.

TL;DR: Push the static build to a remote, bare repository that has a detached working directory (on the same server). A post-receive hook checks out the files in the public directory.

Prerequisites

• A remote web server to host your site.
• SSH access to your remote server.
• Git installed on your remote server (check with git --version).
• Generate an SSH key if you need one.

On the server

Set up password-less SSH access

First, you need to SSH into your server, and provide the password if prompted.

ssh user@hostname

If there is no ~/.ssh directory in your user’s home directory, create one: mkdir ~/.ssh.

Next, you need to copy your public SSH key (see “Generate an SSH key” above) to the server. This allows you to connect via SSH without having to enter a password each time.

From your local machine – assuming your public key can be found at ~/.ssh/id_rsa.pub – enter the following command, with the correct user and hostname. It will append your public key to the authorized_keys file on the remote server.

ssh user@hostname 'cat >> ~/.ssh/authorized_keys' < ~/.ssh/id_rsa.pub

If you close the connection, and then attempt to establish SSH access, you should no longer be prompted for a password.

Create the remote directories

You need to have 2 directories for each domain you want to host. One for the Git repository, and one to contain the checked out build.

For example, if your domain were example.com and you also wanted a staging environment, you’d create these directories on the server:

mkdir ~/example.com ~/example.git

mkdir ~/staging.example.com ~/staging.example.git

Initialize the bare Git repository

Create a bare Git repository on the server. This is where you will push the build assets to, from your local machine. But you don’t want the files served here, which is why it’s a bare repository.

cd ~/example.git
git init --bare

Repeat this step for the staging domain, if you want.

Write a post-receive hook

A post-receive hook allows you to run commands after the Git repository has received commits. In this case, you can use it to change Git’s working directory from example.git to example.com, and check out a copy of the build into the example.com directory.

The location of the working directory can be set on a per-command basis using GIT_WORK_TREE, one of Git’s environment variables, or the --work-tree option.

cat > hooks/post-receive
#!/bin/sh
WEB_DIR=/path/to/example.com

# remove any untracked files and directories
git --work-tree=${WEB_DIR} clean -fd

# force checkout of the latest deploy
git --work-tree=${WEB_DIR} checkout --force

Make sure the file permissions on the hook are correct.

chmod +x hooks/post-receive

If you need to exclude some files from being cleaned out by Git (e.g., a .htpasswd file), you can do that using the --exclude option. This requires Git 1.7.3 or above to be installed on your server.

git --work-tree=${WEB_DIR} clean -fd --exclude=<pattern>

Repeat this step for the staging domain, if you want.

On your local machine

Now that the server configuration is complete, you want to deploy the build assets (not the source code) for the static site.

The build and deploy tasks

I’m using a Makefile, but use whatever you feel comfortable with. What follows is the basic workflow I wanted to automate.

1. Build the production version of the static site.

   make build
   

2. Initialize a new Git repo in the build directory. I don’t want to try and merge the new build into previous deploys, especially for the staging domain.

   git init ./build
   

3. Add the remote to use for the deploy.

   cd ./build
   git remote add origin ssh://user@hostname/~/example.git
   

4. Commit everything in the build repo.

   cd ./build
   git add -A
   git commit -m "Release"
   

5. Force-replace the remote master branch, creating it if missing.

   cd ./build
   git push -f origin +master:refs/heads/master
   

6. Tag the checked-out commit SHA in the source repo, so I can see which SHA’s were last deployed.

   git tag -f production
   

Using a Makefile:

BUILD_DIR := ./build
STAGING_REPO = ssh://user@hostname/~/staging.example.git
PROD_REPO = ssh://user@hostname/~/example.git

install:
    npm install

# Deploy tasks

staging: build git-staging deploy
    @ git tag -f staging
    @ echo "Staging deploy complete"

prod: build git-prod deploy
    @ git tag -f production
    @ echo "Production deploy complete"

# Build tasks

build: clean
    # whatever your build step is

# Sub-tasks

clean:
    @ rm -rf $(BUILD_DIR)

git-prod:
    @ cd $(BUILD_DIR) && 
    git init && 
    git remote add origin $(PROD_REPO)

git-staging:
    @ cd $(BUILD_DIR) && 
    git init && 
    git remote add origin $(STAGING_REPO)

deploy:
    @ cd $(BUILD_DIR) && 
    git add -A && 
    git commit -m "Release" && 
    git push -f origin +master:refs/heads/master

.PHONY: install build clean deploy git-prod git-staging prod staging

To deploy to staging:

make staging

To deploy to production:

make prod

Using Make, it’s a little bit more hairy than usual to force push to master, because the cd commands take place in a sub-process. You have to make sure subsequent commands are on the same line. For example, the deploy task would force push to your source code’s remote master branch if you failed to join the commands with && or ;!

I push my site’s source code to a private repository on BitBucket. One of the nice things about BitBucket is that it gives you the option to prevent deletions or history re-writes of branches.

If you have any suggested improvements, let me know on Twitter.

Mellon, Elizabeth

Bernstein, Aimee

Simpkins, Stacy, author

Interview with Richard G. Bach, MD, author of Effect of Simvastatin-Ezetimibe Compared With Simvastatin Monotherapy After Acute Coronary Syndrome Among Patients 75 Years or Older: A Secondary Analysis of a Randomized Clinical Trial, and Antonio M. Gotto, MD DPhil, author of Intensive Lipid Lowering in Elderly Patients

The responsive images spec is fantastic and covers a lot of use cases, but most of the time you’ll only need one: resolution switching using the `srcset` and `sizes` attributes.

Simon, Eric J. (Eric Jeffrey), 1967- author

Dewey Library - KZ7162.S56 2018

Hayden Library - KF3180.T36 2019

Hayden Library - K4240.H86 2018

£Attractive: University of Oulu
For more latest jobs and jobs in Finland visit brightrecruits.com

€Attractive: CNRS
For more latest jobs and jobs in France visit brightrecruits.com

Krishnadas, Devadas, author

Detailed models highlight a key role for solvents

Bullvalene's constant metamorphosis could be exploited in sensing applications

Bullvalene's constant metamorphosis could be exploited in sensing applications

160-million-atom simulation reveals potential drug targets

Planned changes could mean weaker emission controls for chemical industry